WebApplicationInitializer
to register a DispatcherServlet and use Java-based Spring configuration.Configuration class providing common structure for enabling
Spring's asynchronous method execution capability.BindingResult interface and
its super-interface Errors.ViewResolver
implementations.input'
element with a 'type' of 'checkbox' or 'radio'.ClientHttpRequest that makes sure that headers
and body are not written multiple times.ClientHttpRequest implementations.ClientHttpRequestFactory implementations
that decorate another request factory.AbstractClientHttpRequestFactoryWrapper wrapping the given request factory.ClientHttpResponse.DataFieldMaxValueIncrementer implementations that use
a column in a custom sequence table.ContextLoader SPI.WebApplicationInitializer implementations
that register a ContextLoaderListener in the servlet context.@CookieValue.DataFieldMaxValueIncrementer that delegates
to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long.DataSource
implementations, taking care of the padding.AbstractDelegatingSmartContextLoader serves as an abstract base class
for implementations of the SmartContextLoader SPI that delegate to a
set of candidate SmartContextLoaders (i.e., one that supports XML
configuration files or Groovy scripts and one that supports annotated classes)
to determine which context loader is appropriate for a given test class's
configuration.HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context.TestExecutionListener implementations that
provide support for marking the ApplicationContext associated with
a test as dirty for both test classes and test methods annotated
with the @DirtiesContext annotation.WebApplicationInitializer
implementations that register a DispatcherServlet in the servlet context.DataSource implementations
that operate on a JDBC Driver.EntityInformation.Errors interface.SQLExceptionTranslator implementations that allow for
fallback to some other SQLExceptionTranslator.TransactionAttributeSource that caches
attributes for methods and implements a fallback policy: 1. specific target
method; 2. target class; 3. declaring method; 4. declaring class/interface.FlashMapManager implementations.AbstractContextLoader that loads a
GenericApplicationContext.GenericHttpMessageConverter implementations.AbstractGenericHttpMessageConverter with no supported media types.AbstractGenericHttpMessageConverter with one supported media type.AbstractGenericHttpMessageConverter with multiple supported media type.AbstractContextLoader that loads a
GenericWebApplicationContext.HandlerExceptionResolver implementations.HandlerMapping
implementations.HandlerAdapter implementations that support
handlers of type HandlerMethod.HandlerExceptionResolver
implementations that support handling exceptions from handlers of type HandlerMethod.HandlerMapping implementations that define
a mapping between a request and a HandlerMethod.AbstractHtmlElementTag.HttpMessageConverter implementations.AbstractHttpMessageConverter with no supported media types.AbstractHttpMessageConverter with one supported media type.AbstractHttpMessageConverter with multiple supported media types.AbstractHttpMessageConverter with a default charset and
multiple supported media types.DataFieldMaxValueIncrementer implementations
which are based on identity columns in a sequence-like table.InterruptibleBatchPreparedStatementSetter
interface, combining the check for available values and setting of those
into a single callback method AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int).ObjectMapper to use.ObjectMapper to use.HttpMessageConverter implementations.AbstractView implementations.HttpMessageConverters
that use JAXB2.WebService annotation).DataSource.JdbcTemplate.DataSource.JdbcTemplate.ApplicationContext testing support
in a JUnit environment.Publisher implementations that bridge between
event-listener read APIs and Reactive Streams.AbstractListenerWriteProcessor but instead writing
a Publisher<Publisher<T>> with flush boundaries enforces after
the completion of each nested Publisher.Processor implementations that bridge between
event-listener write APIs and Reactive Streams.PreparedStatementCallback implementation that manages a LobCreator.LobHandler implementations.LocaleContextResolver implementations.LocaleResolver implementations.ContentNegotiationStrategy implementations with the
steps to resolve a request to media types.ResponseBodyAdvice implementations
that customize the response before JSON serialization with
AbstractJackson2HttpMessageConverter's concrete subclasses.Marshaller and Unmarshaller interface.MBeanInfoAssembler interface
that encapsulates the creation of a ModelMBeanInfo instance
but delegates the creation of metadata to subclasses.HttpMessageConverters.Request~ and ResponseBodyAdvice.AbstractMessageConverterMethodArgumentResolver with the ability to handle
method return values by writing to the response with HttpMessageConverters.javax.resource.spi.endpoint.MessageEndpointFactory interface,
providing transaction management capabilities as well as ClassLoader
exposure for endpoint invocations.MockMvcBuilder with common methods for
configuring filters, default request properties, global expectations and
global result actions.input' elements with a 'type'
of 'checkbox' or 'radio'.AbstractNumberFormatter.getNumberFormat(java.util.Locale) template method.JtaTransactionManager.BindingResult implementations that work with
Spring's PropertyAccessor mechanism.PartTree.AbstractQueryCreator for the given PartTree.WebApplicationInitializer
that installs a Spring Reactive Web Application on a Servlet container.RedisCollection.AbstractRedisCollection instance.AbstractMBeanInfoAssembler superclass to
add a basic algorithm for building metadata based on the
reflective metadata of the MBean class.AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments.RepositoryMetadata implementations.AbstractRepositoryMetadata.FactoryBeans creating ResourceReaderRepositoryPopulators.Scope implementation that reads from a particular scope
in the current thread-bound RequestAttributes object.RequestCondition types providing implementations of
AbstractRequestCondition.equals(Object), AbstractRequestCondition.hashCode(), and AbstractRequestCondition.toString().RequestExpectationManager implementations responsible
for storing expectations and actual requests, and checking for unsatisfied
expectations at the end.Filters that perform logging operations before and after a request
is processed.ResourceResolver
implementations.DataSource implementation that routes AbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.DataFieldMaxValueIncrementer implementations that use
a database sequence.ServerHttpRequest implementations.ServerHttpResponse implementations.input' element with a 'type'
of 'checkbox' or 'radio'.org.apache.tiles.preparer.PreparerFactory
interface, obtaining the current Spring WebApplicationContext and delegating to
AbstractSpringPreparerFactory.getPreparer(String, org.springframework.web.context.WebApplicationContext).SqlParameterSource implementations.PreparedStatement.setObject method.AbstractSubscription instance.TestContextBootstrapper interface which
provides most of the behavior required by a bootstrapper.TestExecutionListener API.ApplicationContext testing support in a TestNG
environment.TestContextManager for the current test class.ThemeResolver implementations.AbstractJUnit4SpringContextTests which adds convenience functionality
for JDBC access.AbstractTestNGSpringContextTests which adds convenience functionality
for JDBC access.@Configuration class providing common structure for enabling
Spring's annotation-driven transaction management capability.TransactionStatus interface.DefaultUriBuilderFactoryHandlerMapping
implementations.Controllers that return a view name
based on the request URL.VersionStrategy implementations.VersionPathStrategy,
e.g.VersionPathStrategy,
e.g.View
implementations.WebArgumentResolver to the
HandlerMethodArgumentResolver contract.HttpMessageConverters
that convert from/to XML.supportedMediaTypes
to text/xml and application/xml, and application/*-xml.Accept header field name.Accept header.Accept header.Accept header.Signal instance to a
given Subscriber.Accept-Charset header field name.Accept-Encoding header field name.Accept-Language header field name.Accept-Ranges header field name.Accept-Charset header.Accept-Charset header.Accept-Charset header.LocaleContextResolver implementation that simply uses the primary locale
specified in the "Accept-Language" header of the HTTP request (that is,
the locale sent by the client browser, normally that of the client's OS).LocaleResolver implementation that simply uses the primary locale
specified in the "accept-language" header of the HTTP request (that is,
the locale sent by the client browser, normally that of the client's OS).Accept
headers based on the given response type and configured message converters.Accept
headers based on the given response type and configured
message converters.Accept-Languages header.Access-Control-Allow-Credentials response header field name.Access-Control-Allow-Headers response header field name.Access-Control-Allow-Methods response header field name.Access-Control-Allow-Origin response header field name.Access-Control-Expose-Headers response header field name.Access-Control-Max-Age response header field name.Access-Control-Request-Headers request header field name.Access-Control-Request-Method request header field name.accesskey' attribute.TestContext attribute which indicates that the
ServletTestExecutionListener should be activated.ActiveProfiles is a class-level annotation that is used to declare
which active bean definition profiles should be used when loading
an ApplicationContext
for test classes.ApplicationContext
for a test class.Stream navigating the Subscriber
chain (downward).JobFactory implementation that supports Runnable
objects as well as standard Quartz org.quartz.Job instances.HandlerInterceptor interface.Point with given member name to key.RedisGeoCommands.GeoLocation to key.Map of member / Point pairs to key.RedisGeoCommands.GeoLocations to keyvalues to set at the bound key.value to a sorted set at the bound key, or update its score if it already exists.tuples to a sorted set at the bound key, or update its score if it already exists.Point with given member name to key.RedisGeoCommands.GeoLocation to key.Map of member / Point pairs to key.RedisGeoCommands.GeoLocations to keyPoint with given member name to key.RedisGeoCommands.GeoLocation to key.Map of member / Point pairs to key.RedisGeoCommands.GeoLocations to keyRedisGeoCommands.GeoLocations to keyvalues to set at key.value to a sorted set at key, or update its score if it already exists.values to set at key.value to a sorted set at key, or update its score if it already exists.tuples to a sorted set at key, or update its score if it already exists.Disposable to this container, if it is not disposed.tuples to a sorted set at key, or update their score if it already exists.MultiValueMap to the current values.Collection into this
Map, using attribute name generation for each element.Map into this Map.Collection into this
Map, using attribute name generation for each element.Map into this Map.Collection into this
Map, using attribute name generation for each element.Map into this Map.Collection into this
Map, using attribute name generation for each element.Map into this Map.Errors instance to this
Errors instance.HandlerMethodArgumentResolvers to use in addition to
the ones registered by default.javax.activation.DataSource.java.io.File.org.springframework.core.io.InputStreamResource.org.springframework.core.io.InputStreamResource.Map using a
generated name.Map using a
generated name.Map using a
generated name.Map using a
generated name.CacheControl.ListenableFutureCallback.ResponseCookie.CronTask.Formatter-declared type.Formatter class,
applying it to the specified fields only, if any, or otherwise to all fields.Formatter-declared type.DataSource to the map of DataSources
maintained by this object.RowMapper for the specified parameter or column.HandlerExceptionResolvers.ComparisonResult.EQUAL.ComparisonResult.EQUAL.ObjectError or FieldError to the errors list.MediaTypeFileExtensionResolver instances in addition
to those detected at construction.IntervalTask.Runnable task to be triggered at the given fixed-rate interval.IntervalTask."{version}/js/main.js".generated name.Converters and Formatters.Converters and Formatters in addition to the ones
registered by default.Converters and Formatters in addition to the ones
registered by default.HandlerMethodReturnValueHandler.HandlerMethodReturnValueHandlers.RedisIndexSetting.javax.activation.DataSource.java.io.File.org.springframework.core.io.Resource.org.springframework.core.InputStreamResource, and
specifying the content type explicitly.Environment of the
supplied context.environment.HandlerInterceptor.KeyspaceConfiguration.KeyspaceSettings for type.ComparisonResult.EQUAL.ComparisonResult.EQUAL.ContentNegotiationManagerFactoryBean.setMediaTypes(java.util.Properties) for use in Java code.ContentNegotiationManagerFactoryBean.setMediaTypes(java.util.Properties) for use in Java code.MockServletContext.getMimeType(String).InterceptorRegistration.addPathPatterns(String...).Properties files from the given resource locations
to the Environment of the supplied context.pName parameterized by
classes to this TypeDescription.QueryCreationListener to the factory to plug in functionality triggered right after creation of
RepositoryQuery instances.RepositoryProxyPostProcessors to the factory to allow manipulation of the ProxyFactory before
the proxy gets created.HandlerMethodArgumentResolver.HandlerMethodArgumentResolvers.HandlerMethodArgumentResolvers.ClassLoader.getResource
(also suitable for use with Class.getResource by prepending a
slash ('/') to the return value).HandlerMethodReturnValueHandlers in addition to the
ones registered by default.RedisClusterNode.SlotRange to given node.SimpleMappingExceptionResolver.setStatusCodes(Properties) for use with
Java-based configuration.String to the given String array,
returning a new array consisting of the input array contents plus
the given String.Throwable on a RuntimeException."Multiple exceptions" message, if the atomic reference already holds
one.ClassFileTransformer to be applied by this
LoadTimeWeaver.ClassFileTransformer to be applied by this ClassLoader.Trigger.TriggerTask.ServerWebExchange.transformUrl(java.lang.String).WebRequestInterceptor.TestContextManager.afterTestClass().afterCompletion callback: invoked after commit/rollback.postHandle and afterCompletion, when the
handler started handling the request concurrently.postHandle and afterCompletion
when the handler is being executed concurrently.MockMvcConfigurer is added via
ConfigurableMockMvcBuilder.apply(org.springframework.test.web.servlet.setup.MockMvcConfigurer).afterDelivery implementation resets the thread context
ClassLoader and completes the transaction, if any.MBeanServerConnection if the "connectOnStartup"
is turned on (which it is by default).proxyInterface has been specified and then
generates the proxy for the target MBean.Properties configured in the mappings and
mappingLocations into the final Properties instance
used for ObjectName resolution.JMXConnector for the given settings
and exposes the associated MBeanServerConnection.MBeanServer instance.initialize() after the container applied all property values.ScheduledTaskRegistrar.scheduleTasks() at bean construction time."methodMap", if any.initFilterBean() method that might
contain custom initialization of a subclass.@DirtiesContext and the class mode is set to AFTER_CLASS, the application context of the test context will be
marked as dirty, and the
REINJECT_DEPENDENCIES_ATTRIBUTE in the test context will be set to
true.test method in the supplied
test context — for example, for timing
or logging purposes.@Sql for the supplied
TestContext after the current test method.@DirtiesContext and the method mode is set to AFTER_METHOD, or if the test class is
annotated with @DirtiesContext and the class mode is set to AFTER_EACH_TEST_METHOD, the
application context of the test context
will be marked as dirty and the
REINJECT_DEPENDENCIES_ATTRIBUTE in the test context will be set to true.@AfterTransaction methods.ServletTestExecutionListener.RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE in the supplied
TestContext has a value of Boolean.TRUE, this method will
(1) clean up thread-local state after each test method by resetting Spring Web's
RequestContextHolder and (2) ensure that new mocks are injected
into the test instance for subsequent tests by setting the
DependencyInjectionTestExecutionListener.REINJECT_DEPENDENCIES_ATTRIBUTE
in the test context to true.void method
should be executed after a transaction is ended for a test method
configured to run within a transaction via Spring's @Transactional
annotation.Age header field name.RedisZSetCommands.Aggregate function.RedisZSetCommands.Aggregate function.WaitStrategy.isAlert(Throwable)ReactiveListCommands.LRemCommand to delete all values.Predicate.MediaType.ALL.MimeTypeUtils.ALL.FormHttpMessageConverter,
adding support for XML and JSON-based parts.Allow header field name.HTTP methods, as specified
by the Allow header.IdGenerator that uses SecureRandom for the initial seed and
Random thereafter, instead of calling UUID.randomUUID() every
time as JdkIdGenerator does.MockMvc should always be used regardless of
what the request looks like.MethodLookup that represents a concatenation of this predicate and another.
AnnotatedTypeScanner for the given annotation types.AnnotatedTypeScanner for the given annotation types.AsyncExecutionInterceptor that delegates method execution to
an Executor based on the Async annotation.AnnotationAsyncExecutionInterceptor with the given executor
and a simple AsyncUncaughtExceptionHandler.AnnotationAsyncExecutionInterceptor with the given executor.AbstractGenericContextLoader that loads
bean definitions from annotated classes.SmartContextLoaders that deal
with annotated classes (e.g., @Configuration classes).WebApplicationContext
implementation which accepts annotated classes as input - in particular
@Configuration-annotated
classes, but also plain @Component
classes and JSR-330 compliant classes using javax.inject annotations.AbstractGenericWebContextLoader that loads
bean definitions from annotated classes.ReflectionUtils.FieldCallback that will inspect each field for a given annotation.AnnotationDetectionFieldCallback scanning for an annotation of the given type.ReflectionUtils.MethodCallback to find annotations of a given type.AnnotationDetectionMethodCallback for the given annotation type.AnnotationDetectionMethodCallback for the given annotation type.@Transactional methods.Annotation.AnnotationIntrospector for both serialization and deserialization.JmxAttributeSource interface that
reads annotations and exposes the corresponding attributes.MBeanExporter,
activating Java 5 annotation usage for JMX exposure of Spring beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc.RepositoryConfigurationSource.AnnotationRepositoryConfigurationSource from the given AnnotationMetadata and
annotation.RepositoryMetadata implementation inspecting the given repository interface for a
RepositoryDefinition annotation.AnnotationRepositoryMetadata instance looking up repository types from a
RepositoryDefinition annotation.TransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format.Transactional annotation
or the EJB3 javax.ejb.TransactionAttribute annotation.Transactional annotation
or the EJB3 javax.ejb.TransactionAttribute annotation.PathMatcher implementation for Ant-style path patterns.AntPathMatcher.DEFAULT_PATH_SEPARATOR.Pattern.Comparator implementation returned by
AntPathMatcher.getPatternComparator(String).Flux sequence match
the predicate.AopTestUtils is a collection of AOP-related utility methods for
use in unit and integration testing scenarios.ResourceTransformer implementation that helps handling resources
within HTML5 AppCache manifests for HTML5 offline applications.RedisConnection.stringCommands()}.value to key.value to key.value to the bound key.value to key.value to key.RepositoryComposition retaining current configuration and append RepositoryFragment to
the new composition.RepositoryComposition retaining current configuration and append RepositoryComposition.RepositoryFragments
to the new composition.RepositoryComposition.RepositoryFragments from the current content appending RepositoryFragment.RepositoryComposition.RepositoryFragments from the current content appending RepositoryComposition.RepositoryFragments.DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType).DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType) or DefaultComparisonFormatter.appendFullDocumentHeader(java.lang.StringBuilder, org.w3c.dom.Document) if it contains
non-default values.DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType).DefaultComparisonFormatter.getFullFormattedXml(org.w3c.dom.Node, org.xmlunit.diff.ComparisonType, boolean).ObjectName with the key being
the static value identity and the value being the identity hash code of the
managed resource being exposed on the supplied ObjectName.StringBuilder.StringBuilder.DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType).DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType).DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType) if present.application/atom+xml.MediaType.APPLICATION_ATOM_XML.application/x-www-form-urlencoded.MediaType.APPLICATION_FORM_URLENCODED.application/json.application/json.application/json;charset=UTF-8.MediaType.APPLICATION_JSON_UTF8.MediaType.APPLICATION_JSON.MimeTypeUtils.APPLICATION_JSON.application/octet-stream.application/octet-stream.MediaType.APPLICATION_OCTET_STREAM.MimeTypeUtils.APPLICATION_OCTET_STREAM.application/pdf.MediaType.APPLICATION_PDF.application/problem+json.application/problem+json.MediaType.APPLICATION_PROBLEM_JSON_UTF8.MediaType.APPLICATION_PROBLEM_JSON.application/problem+xml.MediaType.APPLICATION_PROBLEM_XML.application/rss+xml.MediaType.APPLICATION_RSS_XML.application/stream+json.MediaType.APPLICATION_STREAM_JSON.application/xhtml+xml.MediaType.APPLICATION_XHTML_XML.application/xml.application/xml.MediaType.APPLICATION_XML.MimeTypeUtils.APPLICATION_XML.ApplicationContext in order to autowire Jackson handlers (JsonSerializer,
JsonDeserializer, KeyDeserializer, TypeResolverBuilder and TypeIdResolver).ApplicationContext that was injected into this test instance
via AbstractJUnit4SpringContextTests.setApplicationContext(ApplicationContext).ApplicationContext that was injected into this test instance
via AbstractTestNGSpringContextTests.setApplicationContext(ApplicationContext).ApplicationContext.@ApplicationScope is a specialization of @Scope for a
component whose lifecycle is bound to the current web application.base statement.base
statement.MockMvcConfigurer that automates MockMvc setup and
configures it for some specific purpose (e.g. security).AbstractClientHttpRequest.getHeaders() to the underlying response.AbstractServerHttpResponse.getHeaders() to the underlying response.currencyTimeLimit field to the specified
"defaultCurrencyTimeLimit", if any (by default none).AbstractClientHttpRequest.getHeaders() to the underlying response.AbstractServerHttpResponse.getHeaders() to the underlying response.ApplicationContextInitializer instances specified by the
"contextInitializerClasses" servlet init-param.ApplicationContext's lifecycle methods
to the given View instance, if such a context is available.CorsConfiguration does not permit any
cross-origin requests and must be configured explicitly to indicate what
should be allowed.Collection of weights.List of weights.spring:argument tags.PreparedStatementSetter that applies a given array of arguments.<argument> tag is based on the JSTL fmt:param tag.PreparedStatementSetter that applies
given arrays of arguments and JDBC argument types.String array into a comma delimited String
(i.e., CSV).String array into a delimited String (e.g.Flux into a target type.Mono into a target type.Bucket.modelName
exists and checks it type, based on the expectedType.AssertionError if not.Tag has any ancestor tag
of the supplied type, throwing an IllegalStateException
if not.expectedValue to the value from the model
bound under the given modelName.expectedModel to see if all elements in the
model appear and are equal.Node and apply a Matcher.Node,
and assert it with the given Matcher<Node>.AssertionError otherwise.Method's return type to be one of the given types.DOMSource and apply a Matcher.true and raise an
AssertionError if it is not.content
and assert the resulting value with the given Matcher.JsonPathExpectationsHelper.assertValue(String, Matcher) that also
accepts a target type for the resulting value.content
and assert that the result is equal to the expected value.content
and assert that the resulting value is an array.content
and assert that the resulting value is a Boolean.content
and assert that an empty value exists at the given path.content
and assert that the resulting value is a Map.content
and assert that a non-empty value exists at the given path.content
and assert that the resulting value is a Number.content
and assert that the resulting value is a String.expectedName.AssertionError, decorate
with AssertionError containing diagnostic information about the
request and response, and then re-throw.Async
annotation.AsyncAnnotationAdvisor for bean-style configuration.AsyncAnnotationAdvisor for the given task executor.Async annotation at class or
method-level by adding a corresponding AsyncAnnotationAdvisor to the
exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces).org.springframework.web.reactive.function.client.ClientRequestorg.springframework.web.reactive.function.client.ExchangeFilterFunctionClientHttpConnectororg.springframework.web.reactive.function.client.ExchangeFilterFunctionAbstractAsyncConfiguration should be used based
on the value of EnableAsync.mode() on the importing @Configuration class.Configuration classes annotated with @EnableAsync that wish to customize the
Executor instance used when processing async method invocations or the
AsyncUncaughtExceptionHandler instance used to process exception thrown from
async method with void return type.AsyncConfigurer that implements all methods
so that the defaults are used.RequestBuilder for an async dispatch from the
MvcResult of the request that started async processing.HandlerInterceptor with a callback method invoked after the
start of asynchronous request handling.Publisher-based content.MultipartBodyBuilder.asyncPart(String, Publisher, Class) that accepts a
ParameterizedTypeReference for the element type, which allows
specifying generic type information.org.springframework.web.reactive.function.client.ExchangeFilterFunctionorg.springframework.web.reactive.function.client.WebClientorg.springframework.web.reactive.function.client.WebClientAsyncRestTemplate using default settings.AsyncRestTemplate using the given
AsyncTaskExecutor.AsyncRestTemplate using the given
AsyncClientHttpRequestFactory.AsyncRestTemplate using the given
asynchronous and synchronous request factories.AsyncRestTemplate using the given
AsyncClientHttpRequestFactory and synchronous RestTemplate.Future handle that can be used for method signatures
which are declared with a Future return type for asynchronous execution.Callable or DeferredResult.WebAsyncTask.NativeWebRequest with methods for asynchronous request processing.WebRequestInterceptor with a callback method invoked during
asynchronous request handling.HttpMessageConverter
that can read and write Atom feeds.Matcher.Matcher.Matcher.Matcher.RedisURI.setPassword(String)Authorization header field name.ConnectableFlux to the upstream source when the first Subscriber
subscribes.ConnectableFlux to the upstream source when the specified amount of
Subscriber subscribes.ConnectableFlux to the upstream source when the specified amount of
Subscriber subscribes and calls the supplied consumer with a runnable that allows disconnecting.MBeanInfoAssembler should be able
to autodetect beans.MBeanInfoAssembler to add autodetection logic.FreeMarkerConfig object via the ApplicationContext.MapperFeature.AUTO_DETECT_FIELDS option.MapperFeature.AUTO_DETECT_SETTERS/
MapperFeature.AUTO_DETECT_GETTERS/MapperFeature.AUTO_DETECT_IS_GETTERS
options.for' attribute value for this tag.id' attribute value for this tag.id' attribute.List wrapper class that allows for elements to be
automatically populated as they are requested.AutoPopulatingList that is backed by a standard
ArrayList and adds new instances of the supplied element Class
to the backing List on demand.AutoPopulatingList that is backed by the supplied List
and adds new instances of the supplied element Class to the backing
List on demand.AutoPopulatingList that is backed by a standard
ArrayList and creates new elements on demand using the supplied AutoPopulatingList.ElementFactory.AutoPopulatingList that is backed by the supplied List
and creates new elements on demand using the supplied AutoPopulatingList.ElementFactory.List.BackOffExecution that indicates the rate at which
an operation should be retried.Subscriber implementation that lets the user
perform a BaseSubscriber.request(long) and BaseSubscriber.cancel() on it directly.WebClient.create(String).ClientHttpRequestInterceptor to apply a BASIC authorization header.RedisPersistentEntity implementation.BasicRedisPersistentEntity.JdbcTemplate class.DataSourceLookup implementation based on a Spring BeanFactory.BeanFactoryDataSourceLookup class.BeanFactoryDataSourceLookup class.TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional.View beans.BeanNameUrlHandlerMapping ordered at 2 to map URL
paths to controller bean names.HandlerMapping
interface that map from URLs to beans with names that start with a slash ("/"),
similar to how Struts maps URLs to action names.ViewResolver
that interprets a view name as a bean name in the current application context,
i.e. typically in the XML file of the executing DispatcherServlet.Errors and BindingResult
interfaces, for the registration and evaluation of binding errors on
JavaBean objects.BeanPropertyBindingResult class.BeanPropertyBindingResult class.RowMapper implementation that converts a row into a new instance
of the specified mapped target class.BeanPropertyRowMapper for bean-style configuration.BeanPropertyRowMapper, accepting unpopulated
properties in the target bean.BeanPropertyRowMapper.SqlParameterSource implementation that obtains parameter values
from bean properties of a given JavaBean object.@myBeanName and &myBeanName expressions.BeanUtilsHashMapper for the given type.BeanPostProcessor that checks JSR-303 constraint annotations
in Spring-managed beans, throwing an initialization exception in case of
constraint violations right before calling the bean's init method (if any).TestContextManager.beforeTestClass().HttpMessageConverter is selected and just before
its write method is invoked.MappingJackson2HttpMessageConverter.beforeCompletion callback: just invoked before commit.Callable is submitted for concurrent handling.beforeDelivery implementation starts a transaction,
if necessary, and exposes the endpoint ClassLoader as current
thread context ClassLoader.DispatcherServlet.TestExecutionListener.beforeTestClass(org.springframework.test.context.TestContext) and TestExecutionListener.afterTestClass(org.springframework.test.context.TestContext)
by dirtying the context if appropriate (i.e., according to the required mode).TestExecutionListener.beforeTestMethod(org.springframework.test.context.TestContext) and TestExecutionListener.afterTestMethod(org.springframework.test.context.TestContext)
by dirtying the context if appropriate (i.e., according to the required modes).@DirtiesContext and the class mode is set to BEFORE_CLASS, the application context of the test context will be
marked as dirty, and the
REINJECT_DEPENDENCIES_ATTRIBUTE in the test context will be set to
true.test method in the supplied
test context — for example, for timing
or logging purposes.@Sql for the supplied
TestContext before the current test method.DependencyInjectionTestExecutionListener.REINJECT_DEPENDENCIES_ATTRIBUTE in the supplied
test context has a value of Boolean.TRUE,
this method will have the same effect as
prepareTestInstance();
otherwise, this method will have no effect.@DirtiesContext and the method mode is set to BEFORE_METHOD, or if the test class is
annotated with @DirtiesContext and the class mode is set to BEFORE_EACH_TEST_METHOD, the
application context of the test context
will be marked as dirty and the
REINJECT_DEPENDENCIES_ATTRIBUTE in the test context will be set to true.@BeforeTransaction methods and start a new
transaction.RequestContextHolder, but only if the
test class is annotated with
@WebAppConfiguration.void method
should be executed before a transaction is started for a test method
configured to run within a transaction via Spring's @Transactional
annotation.HttpServletRequest attribute that contains the
best matching pattern within the handler mapping.min and max number of times.RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().DefaultStringRedisConnection.bgReWriteAof().RedisServerCommands.bgReWriteAof().enableTranactionSupport is set to true.<hasBindErrors> tag provides an Errors instance in case of
bind errors.ConcurrentModel that automatically removes
the BindingResult object when its corresponding
target attribute is replaced through regular Map operations.ExtendedModelMap that automatically removes
a BindingResult object if the corresponding
target attribute gets replaced through regular Map operations.DataBinder's missing field errors,
and for translating a PropertyAccessException to a
FieldError.WebDataBinder to
ServletRequestDataBinder before binding.<bind> tag supports evaluation of binding errors for a certain
bean or bean property.MockRestServiceServer that should be used
to reply to the given RestTemplate.AsyncRestTemplate itselfMockRestServiceServer that should be used
to reply to the given RestGatewaySupport.RouterFunction.WebTestClient.bindToServer() with a pre-configured connector.ReactiveStringCommands.GetBitCommand given a key.ReactiveStringCommands.SetBitCommand given a key.RedisConnection.stringCommands()}.RedisConnection.stringCommands()}.ReactiveStringCommands.BitCountCommand given a key.key.key between start and
end.key.key between start and
end.RedisConnection.stringCommands()}.Mono and block indefinitely until a next signal is
received.Mono and block until a next signal is
received or a timeout expires.MonoProcessor.MonoProcessor.Flux and block indefinitely
until the upstream signals its first value or completes.Flux and block until the upstream
signals its first value, completes or a timeout expires.timeout.timeout.Flux and block indefinitely
until the upstream signals its last value or completes.Flux and block until the upstream
signals its last value, completes or a timeout expires.Mono and block indefinitely until a next signal is
received or the Mono completes empty.Mono and block until a next signal is
received, the Mono completes empty or a timeout expires.RedisConnection.listCommands()}.keys.keys (see: RedisListCommands.lPop(byte[])).Resource.BodyInserter.Publisher.TRUE and FALSE.Boolean value found.BootstrapContext encapsulates the context in which the Spring
TestContext Framework is bootstrapped.ResourceAdapterApplicationContext) that it runs in.@BootstrapWith defines class-level metadata that is used to determine
how to bootstrap the Spring TestContext Framework.RedisZSetCommands.Range.Boundary to its binary representation suitable for ZRANGEBY* commands, despite
ZRANGEBYLEX.RedisZSetCommands.Range.Boundary to its binary representation suitable for ZRANGEBY* commands, despite
ZRANGEBYLEX.RedisZSetCommands.Range.Boundary to its binary representation suitable for ZRANGEBYLEX command.RedisZSetCommands.Range.Boundary to its binary representation suitable for ZRANGEBYLEX command.GeoOperations bound to a certain key.ReactiveListCommands.BPopCommand.getDirection() element from lists stored at
ReactiveListCommands.BPopCommand.getKeys().RedisConnection.listCommands()}.keys.keys (see: RedisListCommands.rPop(byte[])).RedisConnection.listCommands()}.ReactiveRedisConnection.KeyCommand.getKey(), append it to
ReactiveListCommands.BRPopLPushCommand.getDestination() and return its value.srcKey, append it to dstKey and return its value.srcKey, append it to dstKey and return its value (see
RedisListCommands.rPopLPush(byte[], byte[])).ScriptEvaluator strategy interface.ScriptFactory implementation
for a BeanShell script.RuntimeException that will bubble upstream if thrown
by an operator.RedisData.Collection buffers that
will be emitted by the returned Flux each time the given max size is reached
or once this Flux completes.Collection buffers that
will be emitted by the returned Flux each time the given max size is reached
or once this Flux completes.List buffers, as delimited by the
signals of a companion Publisher this operator will subscribe to.Collection buffers, as
delimited by the signals of a companion Publisher this operator will
subscribe to.List buffers created at a given
timeshift period.BufferingClientHttpRequestFactory wrapper to buffer
the input and output streams, and for example, allow multiple reads
of the response body.Integer attribute implemented by components with a backlog
capacity.HttpMessageConverter that can read and write
BufferedImages.DataBufferFactory that can be used to create the body.ClientHttpRequestFactory that buffers
all outgoing and incoming streams in memory.ClientHttpRequestFactory.backpressure buffering.Collection buffers that
will be emitted by the returned Flux each time the buffer reaches a maximum
size OR the timespan Duration elapses.Collection buffers that
will be emitted by the returned Flux each time the buffer reaches a maximum
size OR the timespan Duration elapses, as measured on the provided Scheduler.List buffers started each time an opening
companion Publisher emits.Collection buffers started each time an opening
companion Publisher emits.JedisClientConfiguration with the configuration applied from this builder.JedisClientConfiguration with the configuration applied from this builder.JedisClientConfiguration with the configuration applied from this builder.LettuceClientConfiguration with the configuration applied from this builder.LettuceClientConfiguration with the configuration applied from this builder.RedisNode.RedisSerializationContext.BeanDefinition from the given source.MultiValueMap with the configured parts.ObjectMapper instance.ServerHttpRequest decorator with the mutated properties.MockRestServiceServer and set up the underlying
RestTemplate or AsyncRestTemplate with a
ClientHttpRequestFactory that creates mock requests.RequestExpectationManager.WebTestClient instance.WebClient configured via this builder.HtmlUnitDriver configured via this builder.MockMvc instance.MockMvc instance.ContentNegotiationManager.HttpHandler.ServerWebExchange decorator with the mutated properties.SseEmitter.send(Object, MediaType).URI instance and replaces URI template variables
with the values from an array.URI instance and replaces URI template variables
with the values from a map.UriComponents instance from the various components contained in this builder.UriComponents instance from the various components
contained in this builder.URI instance and replaces URI template variables
with the values from an array.URI instance and replaces URI template variables
with the values from a map.DiffBuilder.withTest(Object) with the Control-XML DiffBuilder.compare(Object) and return the
collected differences in a Diff object.Source instance.TopicProcessor using the properties
of this builder.WorkQueueProcessor using the properties
of this builder.UriComponents instance and replaces URI template variables
with the values from a map.UriComponents instance and replaces URI template variables
with the values from an array.ContentNegotiationManager based on this configurer's settings.Document from this marshaller's DocumentBuilderFactory,
as a placeholder for a DOM node.JedisClientConfiguration.JedisClientConfigurationBuilder to build JedisClientConfiguration to be used with the
jedis client.LettuceClientConfiguration.LettuceClientConfigurationBuilder to build LettuceClientConfiguration to be used with
the Lettuce client.LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder to build LettucePoolingClientConfiguration
to be used with the Lettuce client.SseEvent.SseEvent, populated with the give data.ContentDisposition.TopicProcessor TopicProcessor.Builder with default properties.WorkQueueProcessor WorkQueueProcessor.Builder with default properties.AbstractAtomFeedView.buildFeedEntries(Map, HttpServletRequest, HttpServletResponse)
to get a list of feed entries.AbstractRssFeedView.buildFeedItems(Map, HttpServletRequest, HttpServletResponse)
to get a list of feed items.field
to the supplied field list.GroovyClassLoader for the given ClassLoader.Integer.MAX_VALUE containing the
DefaultServletHttpRequestHandler instance mapped to "/**";
or null if default servlet handling was not been enabled.HandlerMapping that contains the registered view
controller mappings, or null for no registrations.BootstrapContext associated with this
bootstrapper.BootstrapContext associated with this
bootstrapper.String for the given SQLException.HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, as well as
the HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE before executing the handler.MockHttpServletRequest.DefaultTestContext using the test class
in the BootstrapContext associated with this bootstrapper and
by delegating to AbstractTestContextBootstrapper.buildMergedContextConfiguration() and
AbstractTestContextBootstrapper.getCacheAwareContextLoaderDelegate().TestContext for the BootstrapContext
associated with this bootstrapper.XStreamMarshaller.constructXStream(), XStreamMarshaller.configureXStream(XStream)
and XStreamMarshaller.customizeXStream(XStream).<button> tag renders a form field label in an HTML 'button' tag.ElementSelector that allows two elements to be compared if
their name (including namespace URI, if any) and textual content is
the same and the same is true for all child elements recursively.HttpMessageConverter that can read and write byte arrays.ByteArrayHttpMessageConverter.PropertyEditor for converting
MultipartFiles to byte arrays.byte arrays.Flux into a hot source and cache last emitted signals for further Subscriber.Flux into a hot source and cache last emitted signals for further Subscriber.Flux into a hot source and cache last emitted signals for further
Subscriber.Flux into a hot source and cache last emitted signals for further
Subscriber.Mono into a hot source and cache last emitted signals for further Subscriber.Mono into a hot source and cache last emitted signals for further
Subscriber, with an expiry timeout.Cache-Control header field name.CacheAwareContextLoaderDelegate is responsible for loading and closing application
contexts, interacting transparently with a
ContextCache
behind the scenes.Cache-Control header.ReplayProcessor that caches the last element it has pushed,
replaying it to late subscribers.ReplayProcessor that caches the last element it has pushed,
replaying it to late subscribers.IsNewStrategyFactory that caches resolved IsNewStrategy instances per type to avoid re-resolving them
on each and every request.ResourceResolver that
resolves resources from a Cache or otherwise
delegates to the resolver chain and saves the result in the cache.ResourceTransformer that checks a
Cache to see if a previously transformed resource
exists in the cache and returns it if found, and otherwise delegates to the resolver
chain and saves the result in the cache.Callable.Callable on behalf of the application with
an AsyncTaskExecutor.CallableStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations.PlatformTransactionManager
interface, exposing a method for executing a given callback within a transaction.CallMetaDataProvider implementation
based on the type of database being used.Boolean attribute indicating whether or not a downstream component
has interrupted consuming this scanned component, e.g., a cancelled
subscription.ExecutorService.shutdownNow().true if the comparator can compare these two objects.sourceType can be converted to the targetType.true if the type converter can convert the specified type
to the desired target type.ViewResolver can
handle the supplied view name.ScriptUtils if an SQL script cannot be read.CannotReadScriptException.false since Jaxb2CollectionHttpMessageConverter
required generic type information in order to read a Collection.true if the given media type includes any of the
supported media types.false since Jaxb2CollectionHttpMessageConverter
does not convert collections to XML.false since Jaxb2CollectionHttpMessageConverter
does not convert collections to XML.Integer capacity when no Scannable.Attr.PREFETCH is defined or
when an arbitrary maximum limit is applied to the backlog capacity of the
scanned component.Queue in a best effort fashion.String, changing the first letter to
upper case as per Character.toUpperCase(char).Enum.valueOf(Class, String).Flux produced type into a target produced type.Mono produced type into a target produced type.CastorMappingException with the specified detail message
and nested exception.Converter that supports all classes, but throws exceptions for
(un)marshalling.Jackson2ObjectMapperBuilder instance in order to
build a CBOR data format ObjectMapper instance.PlatformTransactionManager implementation
that manages local transactions for a single CCI ConnectionFactory.Bean wrappers.CdiBean.CdiBean.Bean wrappers.CdiRepositoryBean.CdiRepositoryBean.Extension implementations that create instances for Spring Data repositories.PlatformTransactionManager implementation that orchestrates transaction creation, commits and rollbacks to a
list of delegates.ChainedTransactionManager delegating to the given PlatformTransactionManagers.LocaleResolver.LocaleResolver.MockHttpSession.changeSessionId() if the session is a mock session.ThemeResolver.ThemeResolver.Publisher<T> to write
with and returns Publisher<Void> for the result, this operator helps
to defer the invocation of the write function, until we know if the source
publisher will begin publishing without an error.ChannelTopic instance.CharacterEncodingFilter,
with the encoding to be set via CharacterEncodingFilter.setEncoding(java.lang.String).CharacterEncodingFilter for the given encoding.CharacterEncodingFilter for the given encoding.CharacterEncodingFilter for the given encoding.lastModified flag is effectively ignored,
with a must-revalidate header only generated if explicitly configuredlastModified flag is effectively ignored,
with a must-revalidate header only generated if explicitly configured<checkboxes> tag renders multiple HTML 'input' tags with type 'checkbox'.<checkbox> tag renders an HTML 'input' tag with type 'checkbox'.Access-Control-Request-Headers of a pre-flight request) against
the configured allowed headers.Access-Control-Request-Method header on a pre-flight request)
against the configured allowed methods.ETag (entity tag), as determined by the application.ETag (entity tag) and last-modified timestamp,
as determined by the application.ServerWebExchange.checkNotModified(String, Instant) with
a last-modified timestamp only.ServerWebExchange.checkNotModified(String, Instant) with
an ETag (entity tag) value only.ETag (entity tag) and last-modified timestamp as determined by
the application.AbstractListenerReadPublisher.onDataAvailable()
immediately or schedule a notification.Flux, in case of an error
upstream of the checkpoint.Flux by giving it a description that
will be reflected in the assembly traceback in case of an error upstream of the
checkpoint.forceStackTrace option.Mono, in case of an error
upstream of the checkpoint.Mono by giving it a description that
will be reflected in the assembly traceback in case of an error upstream of the
checkpoint.forceStackTrace option.ParallelFlux, in case of an
error upstream of the checkpoint.ParallelFlux by giving it a description that
will be reflected in the assembly traceback in case of an error upstream of the
checkpoint.forceStackTrace option.TypeInformation for a plain Class.@SessionAttributes or attributes previously stored
in the model that matched by type.HttpServletRequest
attributes under the keys defined in the Servlet 2.3 specification:
javax.servlet.error.status_code,
javax.servlet.error.exception_type,
javax.servlet.error.message,
javax.servlet.error.exception,
javax.servlet.error.request_uri,
javax.servlet.error.servlet_name.CodecConfigurer for HTTP message reader and writer
options relevant on the client side.CodecConfigurer.DefaultCodecs extension with extra client-side options.ClientHttpRequest and receive a ClientHttpResponse.ClientHttpRequest and delegates all methods to it.ClientHttpRequest objects.ClientHttpResponse and delegates all methods to it.clientName to be set with CLIENT SETNAME.ClientOptions.ClientResources.WebHttpHandlerBuilder.clone() method.UriComponentsBuilder.CloseableIterator serves as a bridging data structure for the underlying data store specific results that
can be wrapped in a Java 8 Stream.MergedContextConfiguration from the ContextCache
and close it if it is
an instance of ConfigurableApplicationContext.RedisClusterNode.RedisClusterNode.SlotRange.getSlotsArray() to given RedisClusterNode.RedisClusterNode.RedisClusterNode.SlotRange.getSlotsArray() from given RedisClusterNode.RedisClusterNode serving given key.RedisClusterNode serving given slot.key.ClusterTopology holds snapshot like information about RedisClusterNodes.ClusterTopology.ClusterTopologyProvider manages the current cluster topology and makes sure to refresh cluster information.ServerCodecConfigurer to set on the
WebServerExchange.CodeFlow for the given class.Flux into a user-defined container,
by applying a collector BiConsumer taking the container and each element.mapping and
collection.Collection into a delimited String (e.g., CSV).Collection to a delimited String (e.g.Collection into a delimited String (e.g.Flux until this sequence completes,
and then sort them using a Comparator into a List that is emitted
by the resulting Mono.RowMapper implementation that creates a java.util.Map
for each row, representing all columns as key-value pairs: one
entry for each column, with the column name as key.CorsConfiguration with this one.PathMatcher.combine(String, String).@RequestMapping annotation.Flux whose data are generated by the combination of the most recently published value from each
of the Publisher sources.Flux whose data are generated by the combination of the most recently published value from each
of the Publisher sources.Flux whose data are generated by the combination of the most recently published value from each
of two Publisher sources.Flux whose data are generated by the combination of the most recently published value from each
of three Publisher sources.Flux whose data are generated by the combination of the most recently published value from each
of four Publisher sources.Flux whose data are generated by the combination of the most recently published value from each
of five Publisher sources.Flux whose data are generated by the combination of the most recently published value from each
of six Publisher sources.Matcher.@Commit is a test annotation that is used to indicate that a
test-managed transaction should be committed after
the test method has completed.java.io.Writer adapter for a Commons Logging Log.MultipartFile implementation for Apache Commons FileUpload.MultipartResolver implementation for
Apache Commons FileUpload
1.2 or above.Comparable adapter.Comparator variants.Input.from(Object).== the expected value.== the expected value.ConsumesRequestCondition.getMatchingCondition(HttpServletRequest) and each instance contains
the matching consumable media type expression only or is otherwise empty.HeadersRequestCondition.getMatchingCondition(HttpServletRequest) and each instance
contains the matching header expression only or is otherwise empty.ParamsRequestCondition.getMatchingCondition(HttpServletRequest) and each instance
contains the matching parameter expressions only or is otherwise empty.MediaType.sortByQualityValue(List) and iterate the list.RequestMethodsRequestCondition.getMatchingCondition(HttpServletRequest) and therefore each instance
contains the matching HTTP request method only or is otherwise empty.Comparison Object.ComparisonListeners so it can be
reused by different implementations of DifferenceEngine.ListenableFuture as a JDK CompletableFuture.CompletionStage.CompletableFuture.Sort definition.Signal of variety Type.COMPLETE.GroupedFlux instances keyed by
the zero based rail's index.Disposable.Composite with atomic guarantees on all mutative
operations.Disposable.Composite with atomic guarantees on
all mutative operations.Disposable.Composite with atomic guarantees on
all mutative operations.DatabasePopulator that delegates to a list of given
DatabasePopulator implementations, executing all scripts.CompositeDatabasePopulator.CompositeDatabasePopulator with the given populators.CompositeDatabasePopulator with the given populators.Filter that just delegates its behavior
to a chain (list) of user-supplied filters, achieving the functionality of a
FilterChain, but conveniently using only Filter instances.IndexResolver implementation that iterates over a given collection of delegate
IndexResolver instances.CompositeIndexResolver.CompositeIterator.add(Iterator).RequestCondition contract by delegating to multiple
RequestCondition types and using a logical conjunction (' && ') to
ensure all conditions match a given request.RequestCondition types.TransactionAttributeSource implementation that iterates
over a given array of TransactionAttributeSource instances.UriComponentsContributor containing a list of other contributors
to delegate and also encapsulating a specific ConversionService to
use for formatting method argument values to Strings.UriComponentsContributors or
HandlerMethodArgumentResolvers.UriComponentsContributors or
HandlerMethodArgumentResolvers.UriComponentsContributors or
HandlerMethodArgumentResolvers.Comparator.thenComparing(Comparator)AbstractFallbackTransactionAttributeSource.getTransactionAttribute(java.lang.reflect.Method, java.lang.Class<?>), but doesn't cache the result.byte arrays into one, with overlapping array elements included twice.Iterable, forwarding elements
emitted by the sources downstream.Publisher,
forwarding elements emitted by the sources downstream.Publisher,
forwarding elements emitted by the sources downstream.byte arrays into one, with overlapping array elements included twice.Publisher,
forwarding elements emitted by the sources downstream.Publisher,
forwarding elements emitted by the sources downstream.Publisher,
forwarding elements emitted by the sources downstream.String arrays into one,
with overlapping array elements included twice.Flux with the provided Publisher (no interleave).Mono with the provided Publisher
(no interleave).FluxModel interface based on a ConcurrentHashMap
for use in concurrent scenarios.ConcurrentModel.ModelMap containing the supplied attribute
under the supplied name.ModelMap containing the supplied attribute.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap instance.ConcurrentReferenceHashMap.Entry contained in the map.ConcurrentReferenceHashMap.References.java.util.concurrent.Executor and exposes
a Spring TaskExecutor for it.Executor.SchedulingAwareRunnable
and a given identity name.java.util.concurrent.ScheduledExecutorService and
exposes a Spring TaskScheduler for it.ScheduledExecutorService as shared delegate.Executor
and ScheduledExecutorService as delegates.ElementSelectors by combining simpler blocks.FileTypeMap implementation that will read
MIME type to file extension mappings from a standard JavaMail MIME type
mapping file, using a standard MimetypesFileTypeMap underneath.MockMvc.SmartRequestBuilder that can be configured with RequestPostProcessors.WebBindingInitializer for declarative configuration
in a Spring application context.ConfigurableEnvironment allowing initialization of
servlet-related PropertySource objects at the
earliest moment that the ServletContext and (optionally) ServletConfig
become available.ObjectMapper instance with this builder's
settings.SocketChannelConfig.HandlerExceptionResolvers to use.Transformer.HttpMessageConverters to use
with the RequestMappingHandlerAdapter and the
ExceptionHandlerExceptionResolver.HttpMessageConverters to use for reading or writing
to the body of the request or response.HttpMessageConverters to use for reading or writing
to the body of the request or response.HttpServletResponse.TaskScheduler and specific Task
instances to be registered against the given the ScheduledTaskRegistrarTransformer instance.View
implementations to perform rendering with.View
implementations to perform rendering with.HttpMethod and
URI, then apply the given requestCallback on the
ClientHttpRequest once the connection has been established.ConnectableFlux to its source and return a Runnable that
can be used for disconnecting.ConnectableFlux to its source and sends a Disposable to a callback that
can be used for disconnecting.Connection header field name.javax.resource.cci.ConnectionFactory.SimpleConnectionHandle,
assuming that there is no ongoing transaction.SimpleConnectionHandle.ConnectionProperties serves as a simple data container that allows
essential JDBC connection properties to be configured consistently,
independent of the actual DataSource
implementation.Connection to be implemented by
Connection proxies.javax.resource.cci.ConnectionFactory,
applying the given ConnectionSpec to every standard getConnection()
call, that is, implicitly invoking getConnection(ConnectionSpec)
on the target.RedisConnectionFactoryBean that creates a JSR-160 JMXConnectorServer,
optionally registers it with the MBeanServer and then starts it.ExchangeResult.assertWithDiagnostics(Runnable)
passing "this" instance to it.Consumer.Consumer.Exception
(typically PropertyAccessException)
or a Bean Validation ConstraintViolation.true if any element in 'candidates' is
contained in 'source'; otherwise returns false.CharSequence contains any whitespace characters.String contains any whitespace characters.Content-Disposition header field nameContent-Encoding header field name.Content-Language header field name.Content-Length header field name.Content-Location header field name.Content-Range header field name.Content-Type header field name.HttpServletRequest wrapper that caches all content read from
the input stream and reader,
and allows this content to be retrieved via a byte array.HttpServletResponse wrapper that caches all content written to
the output stream and writer,
and allows this content to be retrieved via a byte array.ContentDisposition.Content-Length header.Content-Length header.Content-Length header.Content-Length header.ViewResolver that resolves a view based on the request file name
or Accept header.ContentNegotiationManager and configures it with
one or more ContentNegotiationStrategy instances.ServletContext.ContentNegotiationStrategy strategies each of which may also be
an instance of MediaTypeFileExtensionResolver.ContentNegotiationManager.ContentNegotiationManager(ContentNegotiationStrategy...).HeaderContentNegotiationStrategy.ContentNegotiationManager and configure it with
one or more ContentNegotiationStrategy instances.RequestMatcher's.Content-Type header.Content-Type header.Content-Type header.MediaType.Content-Type header.Content-Type header.MediaType.isCompatibleWith(MediaType).MediaType.isCompatibleWith(MediaType).MediaType.isCompatibleWith(MediaType).MediaType.isCompatibleWith(MediaType).VersionStrategy that calculates an Hex MD5 hashes from the content
of the resource and appends it to the file name, e.g.ContextCache
statistics.ApplicationContextInitializer classes to use
for initializing the root web application context: "contextInitializerClasses"ContextCache defines the SPI for caching Spring
ApplicationContexts within the
Spring TestContext Framework.ContextCaches.DisposableBean
and haven't been removed before.@ContextConfiguration defines class-level metadata that is used to determine
how to load and configure an ApplicationContext for integration tests.ContextConfigurationAttributes encapsulates the context configuration
attributes declared via @ContextConfiguration.ContextConfigurationAttributes instance with default values.ContextConfigurationAttributes instance for the
supplied @ContextConfiguration annotation and
the test class that declared it.ContextConfigurationAttributes instance for the
supplied AnnotationAttributes (parsed from a
@ContextConfiguration annotation) and
the test class that declared them.ContextConfigurationAttributes instance for the
test class that declared the
@ContextConfiguration annotation and its
corresponding attributes.ContextConfigurationAttributes instance for the
test class that declared the
@ContextConfiguration annotation and its
corresponding attributes.application contexts that are created and managed by the Spring
TestContext Framework.ContextCustomizers.@ContextHierarchy is a class-level annotation that is used to define
a hierarchy of ApplicationContexts for integration tests.ScheduledTaskRegistrar subclass which redirects the actual scheduling
of tasks to the ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated() callback (as of 4.1.2).application context
for an integration test managed by the Spring TestContext Framework.ContextLoader that will create a web application context
based on the "contextClass" and "contextConfigLocation" servlet context-params.ContextLoader with the given application context.WebApplicationContext.ContextLoaderListener that will create a web application
context based on the "contextClass" and "contextConfigLocation" servlet
context-params.ContextLoaderListener with the given application context.HttpHandler delegating requests to one of several HttpHandler's
based on simple, prefix-based mappings.UriComponentsBuilder or add to the map with URI variables
to use to expand the URI after all arguments are processed.HttpServletRequest and HttpServletResponse
instances just like a HttpServlet but is able to
participate in an MVC workflow.ControllerAdvice
instances to be used in tests (specified Class will be turned into instance).@Component for classes that declare
@ExceptionHandler, @InitBinder, or
@ModelAttribute methods to be shared across
multiple @Controller classes.ControllerAdviceBean using the given bean instance.ControllerAdviceBean using the given bean name.converted before handing over.ConversionService in request scope
so it's available during request processing.ConversionServiceExposingInterceptor.XMLException to an appropriate exception from the
org.springframework.oxm hierarchy.RemoteAccessException.ConvertingCursor wraps a given cursor and applies given Converter to items prior to returning them.JAXBException to an appropriate exception from the
org.springframework.oxm hierarchy.JiBXException to an appropriate exception from the
org.springframework.oxm hierarchy.ManagedNotification into the corresponding
ModelMBeanNotificationInfo.Resource handles using
the given ResourceLoader.Resource handles using
the given ResourceLoader.boolean to a String.org.springframework.oxm hierarchy.Cookie header field name.LocaleResolver implementation that uses a cookie sent back to the user
in case of a custom setting, with a fallback to the specified default locale
or the request's accept-header locale.CookieLocaleResolver class
using the default cookie name.ThemeResolver implementation that uses a cookie sent back to the user
in case of a custom setting, with a fallback to the default theme.WebSessionIdResolver.parameter set
of the supplied Transformer.Properties, if any, into the
output property set of the supplied
Transformer.MediaType.src file/directory
to the dest file/directory.src file/directory
to the dest file/directory.Context aware subscriber which has relaxed rules for §1.3 and §3.9
compared to the original Subscriber from Reactive Streams.BeanDefinitionParser that parses a
cors element in order to set the CORS configuration in the various
{AbstractHandlerMapping} beans created by AnnotationDrivenBeanDefinitionParser,
ResourcesBeanDefinitionParser and ViewControllerBeanDefinitionParser.CorsConfiguration instance with no cross-origin
requests allowed for any origin by default.CorsConfiguration instance by copying all
values from the supplied CorsConfiguration.CorsConfiguration instance based on the provided request.CorsConfiguration instance based on the provided reactive request.Filter that handles CORS preflight requests and intercepts
CORS simple and actual requests thanks to a CorsProcessor implementation
(DefaultCorsProcessor by default) in order to add the relevant CORS
response headers (like Access-Control-Allow-Origin) using the provided
CorsConfigurationSource (for example an UrlBasedCorsConfigurationSource
instance.CorsConfigurationSource used by the filter
to find the CorsConfiguration to use for each incoming request.CorsConfiguration and updates
the response.ServerWebExchange, either rejecting through the response or adding
CORS related headers, based on a pre-selected CorsConfiguration.CorsConfiguration instance for a given
URL path pattern.CorsConfiguration mappings.WebFilter that handles CORS preflight requests and intercepts
CORS simple and actual requests thanks to a CorsProcessor implementation
(DefaultCorsProcessor by default) in order to add the relevant CORS
response headers (like Access-Control-Allow-Origin) using the provided
CorsConfigurationSource (for example an UrlBasedCorsConfigurationSource
instance.CorsConfigurationSource used by the filter
to find the CorsConfiguration to use for each incoming request.CorsConfigurationSource used by the filter
to find the CorsConfiguration to use for each incoming request and a
custom CorsProcessor to use to apply the matched
CorsConfiguration for a request.min and max.min and max.ScanOptions.ScanOptionsBuilder configured with the given count.min and max.Example.Example.Flux.sub in string str.WHERE clause.WHERE clause.WHERE clause.#create(CreationalContext, Class, Object) instead.QueryCreationException.create() method on the cached EJB home object.ClientCodecConfigurer.ServerCodecConfigurer.DirectProcessorEmitterProcessor using Queues.SMALL_BUFFER_SIZE
backlog size and auto-cancel.EmitterProcessor using Queues.SMALL_BUFFER_SIZE
backlog size and the provided auto-cancel.EmitterProcessor using the provided backlog size, with auto-cancel.EmitterProcessor using the provided backlog size and auto-cancellation.MonoProcessor that will eagerly request 1 on MonoProcessor.onSubscribe(Subscription), cache and emit
the eventual result for 1 or N subscribers.MonoProcessor that will eagerly request 1 on MonoProcessor.onSubscribe(Subscription), cache and emit
the eventual result for 1 or N subscribers.ReplayProcessor that replays an unbounded number of elements,
using a default internal Queue.ReplayProcessor that replays up to historySize
elements.ReplayProcessor that either replay all the elements or a
limited amount of elements depending on the unbounded parameter.Queues.SMALL_BUFFER_SIZE backlog size,
blockingWait Strategy and auto-cancel.UnicastProcessor that will buffer on an internal queue in an
unbounded fashion.UnicastProcessor that will buffer on a provided queue in an
unbounded fashion.UnicastProcessor that will buffer on a provided queue in an
unbounded fashion.UnicastProcessor that will buffer on a provided queue in an
unbounded fashion.Queues.SMALL_BUFFER_SIZE backlog size,
blockingWait Strategy and auto-cancel.WebHttpHandlerBuilder.applicationContext.AsyncClientHttpRequest for the specified URI
and HTTP method.AsyncClientHttpRequest for the specified URI
and HTTP method.AsyncClientHttpRequest via this template's
AsyncClientHttpRequestFactory.SqlParameterSource objects populated with data
from the values passed in (either a Map or a bean object).SqlParameterSource objects populated with data
from the values passed in (either a Map or a bean object).MapSqlParameterSource objects populated with data from
the values passed in.BeanDefinitionReader for loading
bean definitions into the supplied context.AnnotationConfigContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.PropertiesBeanDefinitionReader.XmlBeanDefinitionReader.AbstractPropertyBindingResult instance using standard
JavaBean property access.BeanWrapper for the underlying target object.WebDataBinder for the given target object and
initialize it through a WebBindingInitializer.WebDataBinder for the given object.ExtendedServletRequestDataBinder.Processor<Publisher<DataBuffer>, Void>
that will write the response body with flushes to the underlying output.HttpRange from the given position to the end.HttpRange from the given fist to last position.WebConnection that will use a MockMvc
instance if one of the specified WebRequestMatcher instances
matches.JDBCConnectionSpec object for the given characteristics.ContentHandler that transforms callback calls to DOM Nodes.ContentHandler that writes to the given StAX XMLStreamWriter.ContentHandler that writes events to the given StAX XMLEventWriter.ContextCustomizer that should be used to customize a
ConfigurableApplicationContext
before it is refreshed.Result for the given XMLStreamWriter.Result for the given XMLEventWriter.Source for the given XMLStreamReader.Source for the given XMLEventReader.MockHttpServletRequest stored in the RequestAttributes
in Spring Web's RequestContextHolder was created by the TestContext
framework.DateTimeFormatter using this factory.DateTimeFormatter using this factory.DateTimeFormatter using this factory.DateTimeFormatter using this factory.JndiLocatorDelegate with its "resourceRef" property set to
true, meaning that all names will be prefixed with "java:comp/env/".XMLInputFactory with Spring's defensive setup,
i.e. no support for the resolution of DTDs and external entities.TransactionAttribute for the supplied target
TransactionAttribute and TestContext, using the names of
the test class and test method to build the name of the transaction.AbstractPropertyBindingResult instance using direct
field access.DispatcherServlet (or other kind of FrameworkServlet-derived
dispatcher) with the specified WebApplicationContext.DocumentBuilder that this marshaller will use for creating
DOM documents when passed an empty DOMSource.DocumentBuilder that this marshaller will use for creating
DOM documents when passed an empty DOMSource.createEndpoint.createEndpoint.AbstractMessageEndpointFactory.AbstractMessageEndpoint inner class of this factory.StandardEnvironment.StandardServletEnvironment.StandardServletEnvironment.StandardServletEnvironment.StandardServletEnvironment.StandardServletEnvironment.XMLStreamReader that reads from a XMLEventReader.XMLStreamWriter that writes to a XMLEventWriter.XMLStreamWriter that writes to a XMLEventWriter.ExceptionHandlerExceptionResolver.ScheduledExecutorService instance.ThreadPoolExecutor or a subclass thereof.ScheduledExecutorService instance.FileTypeMap from the mappings in the given mapping file
and the given mapping entries.ReactiveRedisCallback.HttpContext for the given HTTP method and URI.HttpInputMessage from the given NativeWebRequest.execute method.InputSource from the given resource.Types based on configuration and meta-data information.ServletInvocableHandlerMethod from the given HandlerMethod definition.Marshaller for the given class.IMarshallingContext, configured with the correct indentation.MBeanServer instance and register it with the
MBeanServerFactory, if desired.null) that includes dynamic values and static attributes.CallMetaDataProvider based on the database meta-data.TableMetaDataProvider based on the database meta-data.ModelMBean.ModelMBeanOperationInfo for the
given method.ReactiveRedisCallback.CommonsMultipartFile wrapper for the given Commons FileItem.AbstractNamedValueMethodArgumentResolver.NamedValueInfo object for the given method parameter.HttpOutputMessage from the given NativeWebRequest.PagedResources to be equipped with pagination links downstream.Parameter instance for the given MethodParameter.Parameters instance.Sort parameter.JedisPool.JedisSentinelPool.ConcurrentReferenceHashMap.Reference.ConcurrentReferenceHashMap.ReferenceManager.RepositoryFactorySupport instance.RepositoryFactorySupport creation to TransactionalRepositoryFactoryBeanSupport.doCreateRepositoryFactory() and applies the
TransactionalRepositoryProxyPostProcessor to the created instance.AbstractClientHttpRequestFactoryWrapper.createRequest(URI, HttpMethod, ClientHttpRequestFactory)
with the wrapped request factory provided to the
constructor.ClientHttpRequest for the specified URI and HTTP method
by using the passed-on request factory.ClientHttpRequest for the specified URI and HTTP method.ClientHttpRequest via this template's ClientHttpRequestFactory.RequestConfig to use with the given client.RequestConfig for the given configuration.RequestMappingHandlerAdapter.RequestMappingHandlerMapping.RequestMappingInfo from the supplied
@RequestMapping annotation, which is either
a directly declared annotation, a meta-annotation, or the synthesized
result of merging annotation attributes within an annotation hierarchy.Result used to render the result of the transformation.ContextLoaderListener.ContextLoaderListener.bindTo(restTemplate).build().AsyncRestTemplate itselfbindTo(restGateway).build().DispatcherServlet.DispatcherServlet.MockHttpServletRequest based on the supplied
ServletContext.MockMultipartHttpServletRequest based on the
supplied ServletContext and the MockMultipartFiles
added to this builder.StAXResult for the given XMLStreamWriter.StAXResult for the given XMLEventWriter.StAXSource for the given XMLStreamReader.StAXSource for the given XMLEventReader.Stream backed by the given CloseableIterator and forwarding calls to
BaseStream.close() to the iterator.HttpRange that ranges over the last given number of bytes.TagWriter which all output will be written to.TestContextManager to
prepare the test instance before returning it.TestContextManager for the supplied test class.Thread.Request.Transformer instance used to prefer the XSLT transformation.PreparedStatement.setObject.AssertionError that a sub-class can raise for an
unexpected request.Unmarshaller for the given class.IUnmarshallingContext.XmlWebApplicationContext
or a custom context class, if set.XmlWebApplicationContext
or a custom context class, if set.HandlerMethod is created and returned.Workbook instance.SXSSFWorkbook for streaming the XLSX format.XSSFWorkbook for the XLSX format.XMLContext.XMLEventReader from the given list of XMLEvent.XMLInputFactory that this converter will use to create
XMLStreamReader and XMLEventReader
objects.true, an XmlMapper will be created using its
default constructor.XMLReader that this marshaller will when passed an empty SAXSource.XMLReader that reads from the given StAX XMLStreamReader.XMLReader that reads from the given StAX XMLEventReader.CronSequenceGenerator from the pattern provided,
using the default TimeZone.CronSequenceGenerator from the pattern provided,
using the specified TimeZone.TriggerTask implementation defining a Runnable to be executed according
to a standard
cron expression.CronTask.CronTask.Trigger implementation for cron expressions.CronTrigger from the pattern provided in the default time zone.CronTrigger from the pattern provided in the given time zone.FactoryBean for creating a Quartz org.quartz.CronTrigger
instance, supporting bean-style usage for trigger configuration.ResourceTransformer implementation that modifies links in a CSS
file to match the public URL paths that should be exposed to clients (e.g.javax.money.CurrencyUnit values,
from and to currency code Strings.Context from dependent components which can include downstream
operators during subscribing or a terminal Subscriber.Context.Context.Context.RedisCustomConversions.CustomConversions object.CustomConversions instance registering the given converters.Thread instances.ThreadFactory interface,
allowing for customizing the created threads (name, priority, etc).PageableHandlerMethodArgumentResolver.SortHandlerMethodArgumentResolver.GroovyObject.DispatcherServlet before it is
initialized.ContextLoader.WebApplicationContext
created by this context loader.ConfigurableApplicationContext after
bean definitions have been loaded into the context but before the
context has been refreshed.ConfigurableApplicationContext created by this
ContextLoader after bean definitions have been loaded
into the context but before the context has been refreshed.GenericApplicationContext created by this
ContextLoader after bean definitions have been
loaded into the context but before the context is refreshed.GenericWebApplicationContext created by this context
loader after bean definitions have been loaded into the context but
before the context is refreshed.ConfigurableWebApplicationContext created by this
ContextLoader after config locations have been supplied to the context
but before the context is refreshed.Marshaller created by this
message converter before using it to write the object to the output.Marshaller.AbstractDispatcherServletInitializer.registerDispatcherServlet(ServletContext) has completed.Unmarshaller created by this
message converter before using it to read the object from the input.Unmarshaller.XStream.RepositorySQLExceptionTranslator instances for specific databases.SQLExceptionTranslator instances associated with
specific databases allowing for overriding translation based on values contained in the configuration file
named "sql-error-codes.xml".Validator interface.data field.data field of this event, if available.DatabasePopulator.MethodResolver variant for data binding
purposes, using reflection to access instance methods on a given target object.PropertyAccessor variant for data binding
purposes, using reflection to access properties for reading and possibly writing.Subscriber.onNext(Object).DataSourceFactory encapsulates the creation of a particular
DataSource implementation such as a
SimpleDriverDataSource or a connection pool such as Apache DBCP or C3P0.PlatformTransactionManager
implementation for a single JDBC DataSource.DataSource.Date header field name.DateFormat.Date types.DateTimeFormat declarations.java.time (JSR-310) settings
such as the user's Chronology (calendar system) and time zone.DateTimeContext.DateTimeFormat annotation using a DateFormatter.DateTimeFormatter.DateTimeFormatterFactory instance.DateTimeFormatterFactory instance.DateTimeFormatter.DateTimeFormatterFactory instance.DateTimeFormatterFactory instance.FactoryBean that creates a Joda-Time DateTimeFormatter.FactoryBean that creates a JSR-310 DateTimeFormatter.java.time formatting system for use with Spring.DateTime instances using a DateTimeFormatter.CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given sequence on DB2 LUW (for Linux, Unix and Windows).DataFieldMaxValueIncrementer that retrieves the next value
of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).Db2MainframeMaxValueIncrementerDb2LuwMaxValueIncrementerRedisConnection.serverCommands().RedisConnection.serverCommands().UrlPathHelper.decodeRequestString(HttpServletRequest, String) unless
UrlPathHelper.setUrlDecode(boolean) is set to true in which case it is
assumed the URL path from which the variables were extracted is already
decoded through a call to
UrlPathHelper.getLookupPathForRequest(HttpServletRequest).UrlPathHelper.decodeRequestString(HttpServletRequest, String) unless
UrlPathHelper.setUrlDecode(boolean) is set to true in which case it is
assumed the URL path from which the variables were extracted is already
decoded through a call to
UrlPathHelper.getLookupPathForRequest(HttpServletRequest).Decoder internally wrapped with
DecoderHttpMessageReader).HttpMessageReader that wraps and delegates to a Decoder.Decoder.RedisConnection.ScheduledExecutorService internally used by
Reactor's various Scheduler implementations, allowing to tune the
ScheduledExecutorService backing implementation.RedisConnection.stringCommands()}.ReactiveNumberCommands.DecrByCommand given a key.key by 1.key by 1.RedisConnection.stringCommands()}.key by value.key by value.CorsConfiguration.applyPermitDefaultValues()CorsConfiguration.applyPermitDefaultValues()"*/"."/*".request.getCharacterEncoding
returns null, according to the Servlet spec."--".DataSource: "dataSource".HeaderWebSessionIdResolver.setHeaderName(String).indenting is enabled.CorsConfiguration.applyPermitDefaultValues()_methodnull which we cannot use in annotation attributes.CorsConfiguration.applyPermitDefaultValues()";".TaskExecutor bean to pick up: "taskExecutor".TaskScheduler bean to pick up: "taskScheduler".PlatformTransactionManager:
"transactionManager".ActiveProfilesResolver strategy that
resolves active bean definition profiles based solely on profiles
configured declaratively via ActiveProfiles.profiles() or
ActiveProfiles.value().BindingErrorProcessor implementation.BootstrapContext interface.DefaultBootstrapContext from the supplied arguments.CacheAwareContextLoaderDelegate interface.DefaultCacheAwareContextLoaderDelegate using
a static DefaultContextCache.DefaultCacheAwareContextLoaderDelegate using
the supplied ContextCache.ClientCodecConfigurer.Comparison Object.JedisClientConfiguration.LettuceClientConfiguration with:
SSL
no
Peer Verification
yes
Start TLS
no
Client Options
none
Client Resources
none
Connect Timeout
60 Seconds
Shutdown Timeout
100 Milliseconds
LettucePoolingClientConfiguration with
SSL
no
Peer Verification
yes
Start TLS
no
Client Options
none
Client Resources
none
Connect Timeout
60 Seconds
Shutdown Timeout
100 Milliseconds
pool config
default GenericObjectPoolConfig
ContentNegotiationStrategy to use to determine
the content type to use when no content type is requested.ContextCache API.DefaultContextCache using the maximum cache size
obtained via ContextCacheUtils.retrieveMaxCacheSize().DefaultContextCache using the supplied maximum
cache size.CorsProcessor, as defined by the
CORS W3C recommendation.CorsProcessor,
as defined by the CORS W3C recommendation.RepositoryMetadata.DefaultCrudMethods using the given RepositoryMetadata.WebRequestDataBinder instance and initialize it with a
WebBindingInitializer.DefaultDataBinderFactory instance.DefaultedRedisConnection provides method delegates to Redis*Command interfaces accessible via
RedisConnection.EvaluationContextProvider that always creates a new EvaluationContext.FormattingConversionService configured by default with
converters and formatters appropriate for most applications.DefaultFormattingConversionService with the set of
default converters and
default formatters.DefaultFormattingConversionService with the set of
default converters and,
based on the value of registerDefaultFormatters, the set of
default formatters.DefaultFormattingConversionService with the set of
default converters and,
based on the value of registerDefaultFormatters, the set of
default formattersHandlerExceptionResolver
interface, resolving standard Spring MVC exceptions and translating them to corresponding
HTTP status codes.Ordered.LOWEST_PRECEDENCE.
LettucePoolingClientConfiguration.DefaultLettucePool instance with default settings.Config and RedisClient defaults for configuring the connection poolRedisSentinelConfiguration and RedisClient defaults for configuring the connection pool
based on sentinels.RedisClient defaults for configuring the connection poolLobHandler interface.CustomizableThreadFactory, performing a default lookup
for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment,
falling back to the local CustomizableThreadFactory setup if not found.ConcurrentTaskExecutor, performing a default lookup for
JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7 environment.ConcurrentTaskScheduler, performing a default lookup for
JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Java EE 7 environment.MessageCodesResolver interface.AbstractMockMvcBuilder that provides
the WebApplicationContext supplied to it as a constructor argument.MultipartHttpServletRequest
interface.NodeMatcher that matches control
and tests nodes for comparison with the help of DefaultNodeMatcher.NodeTypeMatcher and ElementSelectors.ElementSelectors.Default and
DefaultNodeMatcher.DefaultNodeTypeMatcher.ElementSelectors and
DefaultNodeMatcher.DefaultNodeTypeMatcher.ElementSelectors and
DefaultNodeMatcher.NodeTypeMatcher.DefaultNodeMatcher.NodeTypeMatcher that marks pairs of nodes of the same
node type as well as pairs of CDATA sections and text nodes as
eligible.Parameters.DefaultParameters instance from the given Method.PropertiesPersister interface.ReactiveScriptExecutor.DefaultReactiveScriptExecutor given ReactiveRedisConnectionFactory and
RedisSerializationContext.RedisList.DefaultRedisList instance.DefaultRedisList instance.DefaultRedisList instance.RedisMap.DefaultRedisMap instance.DefaultRedisMap instance.RedisScript.DefaultRedisScriptDefaultRedisScriptDefaultRedisScriptRedisSet.DefaultRedisSet instance.DefaultRedisSet instance.RedisZSet.DefaultRedisZSet instance with a default score of 1.DefaultRedisZSet instance.DefaultRedisZSet instance with a default score of '1'.DefaultRedisZSet instance.RemoteInvocationExecutor interface.RemoteInvocationFactory interface.@Enable annotation's repositoryBaseClass attribute.RepositoryConfiguration.RepositoryInvokerFactory to inspect the requested repository type and create a
matching RepositoryInvoker that suits the repository best.DefaultRepositoryInvokerFactory for the given Repositories.RepositoryMetadata.DefaultRepositoryMetadata for the given repository interface.RequestExpectation that simply delegates
to the request matchers and the response creator it contains.RequestCount.RequestToViewNameTranslator that simply transforms the URI of
the incoming request into a view name.ResponseCreator with builder-style methods for adding response details.ResponseErrorHandler interface.ScriptExecutor.ServerCodecConfigurer.ServerWebExchange.DefaultServletHandlerConfigurer instance.HttpRequestHandler for serving static files using the Servlet container's "default" Servlet.SessionAttributeStore interface,
storing the attributes in the WebRequest session (i.e.SortParameters.DefaultSortParameters instance.DefaultSortParameters instance.DefaultSortParameters instance.StringRedisConnection.DefaultStringRedisConnection instance.DefaultStringRedisConnection instance.StringRedisConnection.StringTuple interface.DefaultStringTuple instance.DefaultStringTuple instance.TestContext interface.DefaultTestContext
based on the attributes and immutable state of the supplied context.DefaultTestContext from the supplied arguments.TestContextBootstrapper SPI.TransactionDefinition interface,
offering bean-style configuration and sensible default values
(PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).TransactionStatus
interface, used by AbstractPlatformTransactionManager.RedisZSetCommands.Tuple interface.DefaultTuple instance.DefaultTypedTuple instance.TypeResolverBuilder to use for Jackson's default typing.UriBuilderFactory that relies on UriComponentsBuilder for
the actual building of the URI.DefaultUriBuilderFactory.DefaultUriBuilderFactory(String) with a
UriComponentsBuilder.DefaultUriBuilderFactory.
Note: DefaultUriBuilderFactory has a different
default for the parsePath property (from
false to true).
XmlMapper).MapperFeature.DEFAULT_VIEW_INCLUSION option.WebFilterChain.WebSessionManager delegating to a
WebSessionIdResolver for session id resolution and to a
WebSessionStoreDeferredResult provides an alternative to using a Callable for
asynchronous request processing.DeferredResult to be set from a thread
chosen by the application (e.g. in response to some external event).RedisConnection.keyCommands().keys.keys.duration
on a default Scheduler and completes.Boolean whether the scanned component
actively supports error delaying if it manages a backlog instead of fast
error-passing which might drop pending backlog.Mono element (Subscriber.onNext(T) signal) by a given
duration.subscription to this Flux source until the given
period elapses.subscription to this Flux source until the given
period elapses, as measured on the user-provided Scheduler.subscription to this Mono source until the given
period elapses.Mono until another Publisher
signals a value or completes.Flux and generate a Publisher from each of this
Flux elements, each acting as a trigger for relaying said element.Mono and another Publisher that is generated from
this Mono's element and which will be used as a trigger for relaying said element.ConnectionFactory implementation that delegates all calls
to a given target ConnectionFactory.DataSource implementation that delegates all calls
to a given target DataSource.EntityInformations and delegate execution of standard methods from
EntityInformation to a special implementation.ErrorHandler to handle it.DelegatingFilterProxy.DelegatingFilterProxy with the given Filter delegate.DelegatingFilterProxy that will retrieve the named target
bean from the Spring WebApplicationContext found in the ServletContext
(either the 'root' application context or the context named by
DelegatingFilterProxy.setContextAttribute(java.lang.String)).DelegatingFilterProxy that will retrieve the named target
bean from the given Spring WebApplicationContext.org.quartz.Job adapter that delegates to a
given Runnable instance.ServletInputStream.ServletOutputStream.DelegatingSmartContextLoader is a concrete implementation of
AbstractDelegatingSmartContextLoader that delegates to a
GenericXmlContextLoader (or a GenericGroovyXmlContextLoader if Groovy
is present in the classpath) and an AnnotationConfigContextLoader.TransactionAttribute implementation that delegates all calls to a given target
TransactionAttribute instance.TransactionDefinition implementation that delegates all calls to a given target
TransactionDefinition instance.WebConnection that allows delegating to various
WebConnection implementations.WebMvcConfigurationSupport that detects and delegates
to all beans of type WebMvcConfigurer allowing them to customize the
configuration provided by WebMvcConfigurationSupport.keys at the bound key.hashKeys.key.keys.key.keys.MockHttpServletRequestBuilder for a DELETE request.MockHttpServletRequestBuilder for a DELETE request.Context that will resolve all existing keys except the
removed one, key.Publisher.String.Publisher.WHERE clause.WHERE clause.WHERE clause.DELETE requests onto specific handler
methods.File - for directories,
recursively delete any nested directories or files as well.File - for directories,
recursively delete any nested directories or files as well.String that is a delimited list and convert it into a
String array.String that is a delimited list and convert it into
a String array.Flux emits onNext, onError or onComplete Signal
instances, transforming these materialized signals into
real signals on the Subscriber.Mono emits onNext, onError or onComplete Signal
instances, transforming these materialized signals into
real signals on the Subscriber.TestExecutionListener which provides support for dependency
injection and initialization of test instances.CallMetaDataProvider interface.DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table
with the equivalent of an auto-increment column.TableMetaDataProvider.MockHttpSession.serializeState().Converter capable of deserializing GeoResults.ClientConnectionManager's
connection pool, if any.NotificationListener.ApplicationContext is destroyed.JMXConnectorServer managed by an instance of this class.JMXConnector.MBeanServer instance, if necessary.shutdown when the BeanFactory destroys
the task executor instance.String prefixed to the name of a
destruction callback when it is stored in a HttpSession.MappedInterceptor and add them to the list of mapped interceptors.InputStream.ApplicationContextInitializer implementation classes to use
if any have been specified by ContextLoader.CONTEXT_INITIALIZER_CLASSES_PARAM."excludedExecptions", then searching the
"exceptionMappings", and finally using the
"defaultErrorView" as a fallback.key.keys.keys and store result in destKey.keys and store result in destKey.Diff instance.key and otherKey.key and otherKeys.key and otherKey.key and otherKeys.Comparison and its result.key and otherKey and store result in destKey.key and otherKeys and store result in destKey.key and otherKey and store result in destKey.key and otherKeys and store result in destKey.MessageDigestBeanWrapperImpl that falls back to direct field access in case the object or type being
wrapped does not use accessor methods.ApplicationContext
associated with a test is dirty and should therefore be closed
and removed from the context cache.@DirtiesContext is
interpreted when used to annotate a test class.@DirtiesContext is used in a test whose context is
configured as part of a hierarchy via
@ContextHierarchy.@DirtiesContext is
interpreted when used to annotate a test method.TestExecutionListener which provides support for marking the
ApplicationContext associated with a test as dirty for
both test classes and test methods annotated with the
@DirtiesContext annotation.TestExecutionListener which provides support for marking the
ApplicationContext associated with a test as dirty for
both test classes and test methods annotated with the
@DirtiesContext annotation.REINJECT_DEPENDENCIES_ATTRIBUTE in the test context to true.disabled' attribute.disabled' attribute.disabled' attribute.@DisabledIf is used to signal that the annotated test class or test
method is disabled and should not be executed if the supplied
DisabledIf.expression() evaluates to true.DisabledIfCondition is an org.junit.jupiter.api.extension.ExecutionCondition
that supports the @DisabledIf annotation when using the Spring
TestContext Framework in conjunction with JUnit 5's Jupiter programming model.Transformer.RedisTxCommands.multi().RedisOperations.multi().DispatcherServlet that will create its own internal web
application context based on defaults and values provided through servlet
init-params.DispatcherServlet with the given web application context.DispatcherServlet instances that are
managed by MockMvc.ServletWebRequest subclass that is aware of
DispatcherServlet's
request context, such as the Locale determined by the configured
LocaleResolver.dispatchOptionsRequest which allows processing of HTTP OPTIONS requests.Disposable that is itself Disposable.Disposable container that allows updating/replacing its inner Disposable
atomically and with respect of disposing the container itself.Disposable sub-interfaces (Disposable.Composite,
Disposable.Swap).SqlTypeValue that adds a cleanup callback,
to be invoked after the value has been set and the corresponding
statement has been executed.disposed, clear it and then
dispose all the previously contained Disposables.Disposable that is already disposed.Distance between member1 and member2.Distance between member1 and member2 in the given Metric.Distance between member1 and member2.Distance between member1 and member2 in the given Metric.Distance between member1 and member2.Distance between member1 and member2 in the given Metric.Converter capable of converting Double into Distance using given Metric.Subscriber, track elements from this Flux that have been
seen and filter out duplicates.Subscriber, track elements from this Flux that have been
seen and filter out duplicates, as compared by a key extracted through the user
provided Function and by the add method
of the Collection supplied (typically a Set).Subscriber, track elements from this Flux that have been
seen and filter out duplicates, as compared by applying a BiPredicate on
an arbitrary user-supplied <C> store and a key extracted through the user
provided Function.count distinct random elements from set at the bound key.count distinct random elements from set at key.count distinct random elements from set at key.Function
using equality.Function and then comparing keys with the supplied BiPredicate.Mono terminates, either by completing downstream successfully or with an error.Flux terminates, either by completing downstream successfully or with an error.Mono terminates, either by
completing downstream successfully or with an error.ScanCursor.close().SmartDataSource doesn't want us to.AbstractClientHttpRequest.doCommit(Supplier) for a request without body.beforeCommit actions, apply the
request headers/cookies, and write the request body.AbstractServerHttpResponse.doCommit(Supplier) for a response without no body.beforeCommit actions, apply the
response status and headers/cookies, and write the response body.RepositoryFactorySupport instance.FrameworkServlet.processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse).rendering, flush any buffered
BodyContent or, if no BodyContent is supplied,
render the default content.button' block tag.form' block tag and removes the form object name
from the javax.servlet.jsp.PageContext.label' tag.options.Assert.doesNotContain(String, String, String)content
and assert that a non-null value does not exist at the given path.content
and assert that a value, including null values, does not exist
at the given path.content
and assert that a value, including null values, does not exist
at the given path.content
and assert that a value, including null values, does not exist
at the given path.SqlParameterSource.SqlParameterSource.SqlParameterSource and returning a generated key.SqlParameterSource and returning all generated keys.SqlParameterSources.HttpURLConnection.Filters and/or Servlet also saving the
request and response.CompositeFilter.setFilters(java.util.List<? extends javax.servlet.Filter>))
and executes them in order.doFilter implementation stores a request attribute for
"already filtered", proceeding without filtering again if the
attribute is already there.doFilter, but guaranteed to be
just invoked once per request within a single request thread.BindStatus instance.TagWriter.TagWriter instance.Flux terminates for any reason,
including cancellation.Mono terminates for any reason,
including cancellation.ServletContext.getResourcePaths to find
matching resources below the web application root directory.getConnection(ConnectionSpec)
method of the target ConnectionFactory, passing in the specified user credentials.getConnection(username, password)
method of the target DataSource, passing in the specified user credentials.WSDataSource.getConnection(JDBCConnectionSpec).IsNewStrategy to be used for the given type.JdbcTemplate.execute with an active JDBC
CallableStatement.CciTemplate.execute with an active CCI Connection.JdbcTemplate.execute with an active JDBC
Connection.CciTemplate.execute with an active CCI Interaction.JdbcTemplate.execute with an active JDBC
PreparedStatement.ReactiveRedisTemplate.execute(ReactiveRedisCallback) with an active Redis connection.RedisTemplate with an active Redis connection.RedisClusterTemplate with an active Redis connection.JdbcTemplate.execute with an active JDBC
Statement.TransactionTemplate.execute(org.springframework.transaction.support.TransactionCallback<T>) within a transactional context.TransactionTemplate.execute within a transactional
context.RmiInvocationHandler.RmiInvocationHandler.Matcher.Converter to convert arbitrary input into domain classes managed
by Spring Data CrudRepositorys.DomainClassConverter for the given ConversionService.path against the given pattern.Flux is cancelled.Mono is cancelled.Flux completes successfully.Flux emits an item, fails with an error
or completes successfully.Mono emits an item, fails with an error
or completes successfully.ParallelFlux emits an item, fails with an error
or completes successfully.Flux completes with an error.Flux completes with an error matching the given exception type.Flux completes with an error matching the given exception.Mono completes with an error.Mono completes with an error matching the given exception type.Mono completes with an error matching the given predicate.Flux emits an item.Mono emits a data successfully.LongConsumer when this Flux
receives any request.LongConsumer when the Mono receives any request.Flux is subscribed.Mono is subscribed.Mono completes successfully.Mono terminates, either by completing successfully or with an error.Flux terminates, either by
completing successfully or with an error.Mono terminates, either by completing successfully or with an error.ParallelFlux terminates, either by completing successfully or with an error.ScanCursor.open().FrameworkServlet.processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse), if desired.afterCompletion on the given Spring TransactionSynchronizations.ModelAndView that represents a specific error page if appropriate.@ExceptionHandler method and invoke it to handle the raised exception.DispatcherServlet.doDispatch(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
for the actual dispatching.AbstractFormTag.createTagWriter() and passes
the created TagWriter to the AbstractFormTag.writeTagContent(TagWriter) method.FrameworkServlet.processRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse), if desired.Subscriber or -1 if untracked.Subscriber or -1 if untracked.Subscriber that does not check for double onSubscribe
and purely request Long.MAX.DataSource interface,
configuring the plain old JDBC DriverManager via bean properties, and
returning a new Connection from every getConnection call.RedisConnection.keyCommands().key.key.message via server roundtrip.message via server roundtrip.javax.ejb.TransactionAttribute
annotation.Flux into Tuple2<Long, T>
of timemillis and source data.Flux into Tuple2<Long, T>
of timemillis and source data.Mono into Tuple2<Long, T>
of timemillis and source data.Mono sequence into Tuple2<Long, T>
of timemillis and source data.Scheduler that dynamically creates ExecutorService-based Workers and caches
the thread pools, reusing them once the Workers have been shut down.ReactiveListCommands.LIndexCommand given an index.ReactiveListCommands.LSetCommand given an index.IndexOutOfBoundsException
if the sequence is shorter.PathContainer.Separator or PathContainer.PathSegment.DefaultNodeMatcher for selecting matching
elements.ElementSelectors by combining simpler blocks.whens have returned false.EmbeddedDatabase serves as a handle to an embedded database instance.DefaultResourceLoader.ResourceLoader.EmbeddedDatabaseConfigurer encapsulates the configuration required to
create, connect to, and shut down a specific type of embedded database such as
HSQL, H2, or Derby.EmbeddedDatabase instance.EmbeddedDatabaseFactory that implements FactoryBean
for registration as a Spring bean.RepositoryComposition.RepositoryComposition.RepositoryFragments.Streamable.HttpEntity, with no body or headers.HttpHeaders instance (immutable).Flux that completes without emitting any item.Mono that completes without emitting any item.ContextInputStream.SqlParameterSource interface.Subscriber that is expected to be used as a placeholder and
never actually be called.<task:*> XML namespace.ContentNegotiatingViewResolver to front all other
configured view resolvers and select among all selected Views based on
media types requested by the client (e.g. in the Accept header).ContentNegotiatingViewResolver to front all other
configured view resolvers and select among all selected Views based on
media types requested by the client (e.g. in the Accept header).@EnabledIf is used to signal that the annotated test class or test
method is enabled and should be executed if the supplied
EnabledIf.expression() evaluates to true.EnabledIfCondition is an org.junit.jupiter.api.extension.ExecutionCondition
that supports the @EnabledIf annotation when using the Spring
TestContext Framework in conjunction with JUnit 5's Jupiter programming model.Transformer.Transformer.<task:*> XML namespace.QuerydslWebConfiguration as configuration class if Querydsl is on the
classpath.<tx:*> XML namespace.@Configuration class imports the Spring MVC
configuration from WebMvcConfigurationSupport, e.g.:
@Configuration
@EnableWebMvc
@ComponentScan(basePackageClasses = MyConfiguration.class)
public class MyConfiguration {
}
To customize the imported configuration, implement the interface
WebMvcConfigurer and override individual methods, e.g.:
@Configuration
@EnableWebMvc
@ComponentScan(basePackageClasses = MyConfiguration.class)
public class MyConfiguration implements WebMvcConfigurer {
@Override
public void addFormatters(FormatterRegistry formatterRegistry) {
formatterRegistry.addConverter(new MyConverter());
}
@Override
public void configureMessageConverters(List<HttpMessageConverter<?UriComponents.encode(Charset) that uses "UTF-8" as the charset.UriUtils.decode(String, Charset) with a String charset.Encoder, internally wrapped with
EncoderHttpMessageWriter.Encoder, internally wrapped with
EncoderHttpMessageWriter.MockHttpServletResponse.encodeURL(java.lang.String),
returning the given URL String as-is.HttpMessageWriter that wraps and delegates to an Encoder.Encoder.UriUtils.encode(String, Charset) to all
given URI variable values.UriUtils.encode(String, Charset) to all
given URI variable values.String ends with the specified suffix,
ignoring upper/lower case.ExchangeResult sub-class that exposes the response body fully
extracted to a representation of type <T>.EntityMetadata to add functionality to query information of entity instances.key.key."^^^ END OF SCRIPT ^^^".ContextConfigurationAttributes instance by comparing both object's
declaring class,
locations,
annotated classes,
inheritLocations flag,
context initializer classes,
inheritInitializers flag, and the
ContextLoader class.MergedContextConfiguration
instance by comparing both object's locations,
annotated classes,
context initializer classes,
active profiles,
property source locations,
property source properties,
parents, and the fully qualified names of their
ContextLoaders.WebMergedContextConfiguration
instance by comparing both object's locations,
annotated classes,
context initializer classes,
active profiles,
resource base path,
parents, and the fully qualified names of their
ContextLoaders.toString() results.Flux that terminates with the specified error immediately after
being subscribed to.Flux that terminates with the specified error, either immediately
after being subscribed to or after being first requested.Mono that terminates with the specified error immediately after
being subscribed to.Signal of variety Type.FAILED, which holds
the error.Signal of variety Type.FAILED, which holds
the error and the Context associated with the erroring source.Throwable attribute which indicate an error state if the scanned
component keeps track of it.UnsupportedOperationException indicating that the error callback
on a subscriber was not implemented, yet an error was propagated.Errors method arguments.<errors> tag renders field errors in an HTML 'span' tag.Appendable instance which automatically escapes all
text appended to it before passing the resulting text to an underlying
Appendable.null
if this code point does not need to be escaped.Appendable instance which automatically escapes all
text appended to it before passing the resulting text to an underlying
Appendable.<escapeBody> tag is used to escape its enclosed body content,
applying HTML escaping and/or JavaScript escaping.ETag header field name.ETag header.RedisConnection.scriptingCommands().script.script.script.RedisConnection.scriptingCommands().RedisConnection.scriptingCommands().scriptSha.scriptSha.scriptSha.scriptSha.<eval> tag evaluates a Spring expression (SpEL) and either prints
the result or assigns it to a variable.@IfProfileValue annotation.Statement in the execution chain (typically an instance of
RunAfters), catching any
exceptions thrown, and then invoke TestContextManager.afterTestClass().Statement in the execution chain (typically an
instance of RunBeforeTestExecutionCallbacks), catching any exceptions
thrown, and then invoke TestContextManager.afterTestExecution(java.lang.Object, java.lang.reflect.Method, java.lang.Throwable) supplying
the first caught exception (if any).Statement in the execution chain (typically an instance of
RunAfters), catching any
exceptions thrown, and then invoke
TestContextManager.afterTestMethod(Object, Method, Throwable) supplying the
first caught exception (if any).TestContextManager.beforeTestClass() and then evaluate
the next Statement in the execution chain (typically an instance
of RunBefores).TestContextManager.beforeTestExecution(Object, Method)
and then evaluate the next Statement in the execution chain
(typically an instance of
InvokeMethod).TestContextManager.beforeTestMethod(Object, Method)
and then evaluate the next Statement in the execution chain
(typically an instance of
RunBefores).TestContextManager.prepareTestInstance(Object) and
then evaluate the next Statement in the execution chain
(typically an instance of RunAfterTestMethodCallbacks).statement in the execution chain
(typically an instance of SpringRepeat) and throw a
TimeoutException if the next statement executes longer
than the specified timeout.statement in the execution chain
repeatedly, using the specified repeat count.@DisabledIf is present on the
corresponding test class or test method and the configured expression evaluates
to true.@EnabledIf is present on the
corresponding test class or test method and the configured expression
evaluates to true.EvaluationContext provided by a ExtensionAwareEvaluationContextProvider.EvaluationContextExtensions.StandardEvaluationContext.event field.event field of this event, if available.RepositoryProxyPostProcessor to register a MethodInterceptor to intercept the
CrudRepository.save(Object) method and publish events potentially exposed via a method annotated with
DomainEvents.ExampleMatcherAccessor instead.ExampleMatcherAccessor for the given ExampleMatcher.ExampleMatcher to use in modules that support query by example (QBE) querying.HandlerExceptionResolver but where no view was rendered
(e.g. setting the status code).@ExceptionHandler methods.AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods.Exception
to the exception types supported by a given Method.ExceptionHandler methods in the given type.WebExceptionHandlers
after the delegate WebHandler.Exception into appropriate DataAccessException.InstanceFilter implementation that handles exception types.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.RequestEntity and return
the response as ResponseEntity.RequestEntity and return
the response as ResponseEntity.WebTestClient.ExchangeStrategies to use.InterceptorRegistration.excludePathPatterns(String...).RedisTxCommands.multi().RedisOperations.multi().RedisSerializer to deserialize any results that are byte[]s or
Collections of byte[]s.RedisSerializers to deserialize any results that are byte[]s or
Collections or Maps of byte[]s or Tuples.RedisScript.RedisScript.RedisScriptRedisScript, using the provided RedisSerializers to serialize the script
arguments and result.RedisCallback via underlying RedisOperations.RedisScriptRedisScript, using the provided RedisSerializers to serialize the script
arguments and result.RedisScriptRedisScriptRedisScriptRedisScript, using the provided RedisSerializers to serialize the script
arguments and result.RedisScriptRedisScript, using the provided RedisSerializers to serialize the script
arguments and result.RepositoryQuery with the given parameters.ClientHttpResponse that can be read.DatabasePopulator against the given DataSource.ResourceDatabasePopulator against the given
DataSource.executeInternal afterwards.AsyncRequestCallback, and reading the response with a
ResponseExtractor.AsyncRequestCallback, and reading the response with a
ResponseExtractor.AsyncRequestCallback, and reading the response with a
ResponseExtractor.RequestCallback, and reading the response with a ResponseExtractor.RequestCallback, and reading the response with a ResponseExtractor.RequestCallback, and reading the response with a ResponseExtractor.response.HttpInvokerRequestExecutor.HttpInvokerRequestExecutor.RedisConnection to the actual return type of the method.ExecutorService to execute as many event-loop consuming the
ringbuffer as subscribers.ExecutorService to execute as many event-loop consuming the
ringbuffer as subscribers.ExecutorService
(typically a ThreadPoolExecutor or
ScheduledThreadPoolExecutor).RedisConnection.keyCommands().key exists.key exists.Example.Example.content
and assert that a non-null value, possibly an empty array or map, exists
at the given path.ServletContext.getResource.Publisher, exists.Single, exists.UriComponents.UriTemplateVariables.Expect header field name.MockRestServiceServer.expect(RequestMatcher) that also indicates how
many times the request is expected to be executed.<B> and then apply assertions.WebTestClient.ResponseSpec.expectBody(Class) that accepts information
about a target type with generics.byte[] and then apply
assertions on the raw content (e.g. isEmpty, JSONPath, etc.)List<E> and then apply
List-specific assertions.WebTestClient.ResponseSpec.expectBodyList(Class) that accepts information
about a target type with generics.TimeUnit.Expiration.RedisConnection.keyCommands().key in seconds.key in seconds.key in seconds.key.key..RedisConnection.keyCommands().key as a UNIX timestamp.key as a UNIX timestamp.key as a UNIX timestamp.key as a UNIX timestamp.key as a expireAt timestamp.key as a date timestamp.Expires header field name.Expiration.BackOff that increases the back off period for each
retry attempt.AbstractHtmlElementBodyTag.writeTagContent(org.springframework.web.servlet.tags.form.TagWriter) allowing subclasses to add any attributes to the
javax.servlet.jsp.PageContext as needed.this key
in the PageContext#PAGE_SCOPE.HttpServletRequest
attributes under the keys defined in the Servlet 2.3 specification, for error pages that
are rendered directly rather than through the Servlet container's error page resolution:
javax.servlet.error.status_code,
javax.servlet.error.exception_type,
javax.servlet.error.message,
javax.servlet.error.exception,
javax.servlet.error.request_uri,
javax.servlet.error.servlet_name.RepositoryConfigurationExtension to indicate the repository configuration for a
particular store (expressed through the extension's concrete type) has appened.@Value.ServletRequestDataBinder that adds URI template variables
to the values used for data binding.HandlerExceptionResolvers after it has been configured.AbstractHandlerMapping.setInterceptors(java.lang.Object...)).EvaluationContextProvider that assembles an EvaluationContext from a list of
EvaluationContextExtension instances.ExtensionAwareEvaluationContextProvider.ExtensionAwareEvaluationContextProvider for the given EvaluationContextExtensions.ExtensionRegistry.prefix.ClientHttpResponse and return it.ResponseErrorHandler that uses HttpMessageConverters to
convert HTTP error responses to RestClientException.ExtractingResponseErrorHandler.ExtractingResponseErrorHandler with the given
HttpMessageConverter instances.execute method.PathMatcher.extractUriTemplateVariables(java.lang.String, java.lang.String).Map<String, Object> of values to use for
data binding purposes.WebApplicationContext
for a given JSF FacesContext.RequestAttributes adapter for a JSF javax.faces.context.FacesContext.WebRequest adapter for a JSF javax.faces.context.FacesContext.JsonFactory to be used to create the ObjectMapper
instance.SerializationFeature.FAIL_ON_EMPTY_BEANS option.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES option.key.FailureCallback.onFailure(Throwable) call on all
added callbacks with the given Throwable.ListenableFuture.IllegalStateException indicating the receiver is overrun by
more signals than expected in case of a bounded queue, or more generally that data
couldn't be emitted due to a lack of requestIllegalStateException indicating the receiver is overrun by
more signals than expected in case of a bounded queue or more generally that data
couldn't be emitted due to a lack of requestRejectedExecutionExceptionRejectedExecutionException with standard message and cause,
unless the cause is already a RejectedExecutionException created
via Exceptions.failWithRejected(Throwable) (not the singleton-producing variants).RejectedExecutionException with a message indicating
the reason is due to the scheduler not being time-capable"\n".ByteArrayOutputStream.FastByteArrayOutputStream
with the default initial capacity of 256 bytes.FastByteArrayOutputStream
with the specified initial capacity.ReactiveGeoCommands.GeoDistCommand for RedisGeoCommands.DistanceUnit.FEET.ReactiveHashCommands.HDelCommand given a field name.ReactiveHashCommands.HExistsCommand given a field name.ReactiveHashCommands.HGetCommand given a field name.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.Descriptor.FieldProperty is a Property which is accessed as
a field, without going through accessor methods (setX, getX).ReactiveHashCommands.HDelCommand given a Collection of field names.ReactiveHashCommands.HGetCommand given a Collection of field names.ReactiveHashCommands.HSetCommand given a Map of field values.Part that represents an uploaded file received in
a multipart request.MockMvcRequestBuilders.multipart(URI)Streamable that will apply the given filter Predicate to the current one.methodParamNameWebFilter through the given WebFilterChain.WebFilter in the chain.Predicate.Mono is valued, test the result and replay it if predicate returns true.MappingJacksonValue container.@JsonFilter annotated POJO.Flux asynchronously using a generated
Publisher<Boolean> test.Flux asynchronously using a generated
Publisher<Boolean> test.Mono is valued, test the value asynchronously using a generated
Publisher<Boolean> test.Page of entities meeting the paging restriction provided in the Pageable object.Example.Example applying the given Sort.Page of entities matching the given Example.Example.Example applying the given Sort.Publisher.ControllerAdviceBean instances.MetaAnnotationUtils.AnnotationDescriptor for the supplied annotationType
on the supplied Class, traversing its annotations, interfaces, and
superclasses if no annotation can be found on the given class itself.MetaAnnotationUtils.UntypedAnnotationDescriptor for the first Class
in the inheritance hierarchy of the specified clazz (including
the specified clazz itself) which declares at least one of the
specified annotationTypes.minPort, 65535].minPort, maxPort].minPort, maxPort].minPort, 65535].minPort, maxPort].minPort, maxPort].Publisher.Single.PropertyEditorRegistry's
editor lookup facility, if available.null if none match.ReflectionUtils.FieldFilter.ReflectionUtils.DescribedFieldFilter.ReflectionUtils.DescribedFieldFilter.candidates' that is contained in
'source'.Method invoked on the composite interface.Method on the supplied class with the supplied name
and no parameters.Method on the supplied class with the supplied name
and parameter types.findObject methods.Example or null if none was found.Example or Mono.empty() if none was found.Revisions of an entity with the given id.Page of revisions for the entity with the given id.WebApplicationContext for this web app: either the
root web app context (preferred) or a unique WebApplicationContext
among the registered ServletContext attributes (typically coming
from a single DispatcherServlet in the current web application).WebApplicationContext passed in at construction time, if available.ReactiveListCommands.LRemCommand to first count values.Publisher to emit any signal (onNext/onError/onComplete) and
replay all signals from that Publisher, effectively behaving like the
fastest of these competing sources.Publisher to emit any signal (onNext/onError/onComplete) and
replay all signals from that Publisher, effectively behaving like the
fastest of these competing sources.Mono to emit any signal (value, empty completion or error)
and replay that signal, effectively behaving like the fastest of these competing
sources.BackOff implementation that provides a fixed interval
between two attempts and a maximum number of retries.ContentNegotiationStrategy that returns a fixed content type.MediaType.MediaType's to return
for use in applications that support a variety of content types.IntervalTask for fixed-delay semantics.FixedDelayTask.LocaleContextResolver implementation that always returns a fixed locale
and optionally time zone.LocaleResolver implementation
that always returns a fixed default locale and optionally time zone.IntervalTask for fixed-rate semantics.FixedRateTask.ThemeResolver implementation
that simply uses a fixed theme.VersionStrategy that relies on a fixed version applied as a request
path prefix, e.g. reduced SHA, version name, release date, etc.FlashMapManager.Streamable that will apply the given Function to the current one.Flux from a java Flow.PublisherAbstractListenerWriteFlushProcessor.isFlushPending() should
return true after.SmartTransactionObject interface.RedisConnection.serverCommands().RedisConnection.serverCommands().javax.servlet.jsp.JspWriter.RedisConnection.serverCommands().RedisConnection.serverCommands().Publisher with rx operators that emits 0 to N elements, and then completes
(successfully or with an error).ExchangeResult variant with the response body decoded as
Flux<T> but not yet consumed.FluxOperator wrapper around the passed parent PublisherFlux API for Processor.Tuple2Tuple3Tuple3 to R.Tuple4Tuple4 to R.Tuple5Tuple4 to R.Tuple6Tuple6 to R.Tuple7Tuple7 to R.Tuple8Tuple8TuplesTuples to R.Sort instance into a List of sort expressions, accumulating Sort.Order instances
of the same direction into a single expression if they are in order.ExecutionException from Future.get().FactoryBean that builds and exposes a preconfigured ForkJoinPool.DefaultMessageCodesResolver.CODE_SEPARATOR.Formatter and PropertyEditor.FormatterPropertyEditorAdapter for the given Formatter.Converters and Formatters with
a FormattingConversionService through the FormatterRegistry SPI.ConversionService implementation
designed to be configured as a FormatterRegistry.FormattingConversionService
configured with converters and formatters for common types such as numbers and
datetimes.MultiValueMap.Part for a form field.HttpMessageConverter to read and write 'normal' HTML
forms and also to write (but not read) multipart data (e.g. file uploads).HttpMessageReader to read HTML form data, i.e.HttpMessageWriter for writing a MultiValueMap<String, String>
as HTML form data, i.e.<form> tag renders an HTML 'form' tag and exposes a binding path to
inner tags for binding.Class.forName() that also returns Class instances
for primitives (e.g.SimpleEvaluationContext for the specified PropertyAccessor
delegates: typically a custom PropertyAccessor specific to a use case
(e.g. attribute resolution in a custom data structure), potentially combined with
a DataBindingPropertyAccessor if property dereferences are needed as well.SimpleEvaluationContext for read-only access to
public properties via DataBindingPropertyAccessor.SimpleEvaluationContext for read-write access to
public properties via DataBindingPropertyAccessor.Future.get().getServerName(),
getServerPort(),
getScheme(),
isSecure(), and
sendRedirect(String).HttpRequest.getURI().FrameworkServlet that will create its own internal web
application context based on defaults and values provided through servlet
init-params.FrameworkServlet with the given web application context.UrlBasedViewResolver
that supports FreeMarkerView (i.e.view class to FreeMarkerViewResolver.requiredViewClass():
by default FreeMarkerView.Point.ReactiveListCommands.BRPopLPushCommand given a sourceKey.ReactiveListCommands.RPopLPushCommand given a sourceKey.Expiration with the provided TimeUnit.Expiration with the provided Duration.RedisElementReader using given RedisSerializer.RedisElementWriter using given RedisSerializer.ClassTypeInformation.From header field name.MockServerWebExchange from the given request.MockServerWebExchange.from(MockServerHttpRequest) that accepts a request
builder.Source, Input.Builder, Document, Node,
byte[] (XML as byte[]), String (XML as String), File (contains XML),
URL (to an XML-Document), URI (to an XML-Document), InputStream,
ReadableByteChannel,
Jaxb-Object (marshal-able with JAXB.marshal(...))Publisher with the Flux API.Publisher with the Mono API, and ensure it will emit 0 or 1 item.parallelism number of 'rails',
possibly ordered and in a round-robin fashion.parallelism number of 'rails'
and in a round-robin fashion and use custom prefetch amount and queue
for dealing with the source Publisher's values.ParallelFlux which runs them in parallel and
unordered.Scannable.Flux that emits the items contained in the provided array.ConversionService.Mono, producing its value using the provided CompletionStage.UriComponentsBuilder from the mapping of a controller class
and current request information including Servlet mapping.MvcUriComponentsBuilder.fromController(Class) that accepts a
UriComponentsBuilder representing the base URL.ServletUriComponentsBuilder.fromContextPath(HttpServletRequest) except the
request is obtained through RequestContextHolder.ServletUriComponentsBuilder.fromRequest(HttpServletRequest) except the
request is obtained through RequestContextHolder.ServletUriComponentsBuilder.fromRequestUri(HttpServletRequest) except the
request is obtained through RequestContextHolder.ServletUriComponentsBuilder.fromServletMapping(HttpServletRequest) except the
request is obtained through RequestContextHolder.Publisher to a Mono without any cardinality check
(ie this method doesn't check if the source is already a Mono, nor cancels the
source past the first element).Scheduler which uses a backing ExecutorService to schedule
Runnables for async operators.Mono, producing its value using the provided CompletableFuture.hash (map) to an object.hash (map) to an object and return the casted result.UriComponents object from the URI associated with
the given HttpRequest while also overlaying with values from the headers
"Forwarded" (RFC 7239),
or "X-Forwarded-Host", "X-Forwarded-Port", and "X-Forwarded-Proto" if
"Forwarded" is not found.Range.MvcUriComponentsBuilder.fromMappingName(String) that accepts a
UriComponentsBuilder representing the base URL.UriComponentsBuilder from the mapping of a controller method
and an array of method argument values.MvcUriComponentsBuilder.fromMethod(Class, Method, Object...)UriComponentsBuilder by invoking a "mock" controller method.MvcUriComponentsBuilder.fromMethodCall(Object) that accepts a
UriComponentsBuilder representing the base URL.UriComponentsBuilder from the mapping of a controller
method and an array of method argument values.MvcUriComponentsBuilder.fromMethodName(Class, String, Object...) that
accepts a UriComponentsBuilder representing the base URL.TypeInformation from the given method's return type.RedisSerializationContext using the given RedisSerializer.RedisSerializationContext.SerializationPair adapter given RedisSerializer.URI.Function for the given method on the given target instance.Fuseable.QueueSubscription.Future parameterized over S into a Future
parameterized over T.FutureAdapter with the given adaptee.FutureResult for given object actually holding the result itself.FutureResult for given object actually holding the result itself and a converter capable of
transforming the result via FutureResult.convert(Object).FutureResult for given object actually holding the result itself and a converter capable of
transforming the result via FutureResult.convert(Object).Flux by generating signals one-by-one via a
consumer callback.Flux by generating signals one-by-one via a
consumer callback and some state.Flux by generating signals one-by-one via a
consumer callback and some state, with a final cleanup callback.BeanDefinition.AnnotationConfigContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.AnnotationConfigWebContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.KeyHolder interface, to be used for
holding auto-generated keys (as potentially returned by JDBC insert statements).CallMetaDataProvider interface.Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml) as bean properties.AbstractGenericContextLoader that reads
bean definitions from Groovy scripts and XML configuration files.AbstractGenericWebContextLoader that loads
bean definitions from Groovy scripts and XML configuration files.HttpMessageConverter that can convert an HTTP request
into a target object of a specified generic type and a source object of a specified
generic type into an HTTP response.GenericJackson2JsonRedisSerializer and configures ObjectMapper for default typing.GenericJackson2JsonRedisSerializer and configures ObjectMapper for default typing using the
given name.ObjectMapper is one way to take further control of the JSON serialization
process.Marshaller that has support for Java 5 generics.javax.resource.spi.endpoint.MessageEndpointFactory interface,
providing transaction management capabilities for any kind of message
listener object (e.g.AbstractGenericContextLoader that reads
bean definitions from Java Properties resources.TableMetaDataProvider interface
which should provide enough features for all supported databases.Unmarshaller that has support for Java 5 generics.GenericApplicationContext, suitable for web environments.AbstractGenericContextLoader that reads
bean definitions from XML resources.AbstractGenericWebContextLoader that loads
bean definitions from XML resources.RedisConnection.geoCommands()}.RedisConnection.geoCommands()}.RedisConnection.geoCommands()}.Point with given member to key.RedisGeoCommands.GeoLocation to key.RedisGeoCommands.GeoLocation to key.RedisGeoCommands.GeoLocations to key.Point with given member name to key.RedisGeoCommands.GeoLocation to key.Map of member / Point pairs to key.RedisGeoCommands.GeoLocations to keyPoint with given member name to key.GeoLocation to key.Map of member / Point pairs to key.GeoLocations to keyBoundGeoOperations.add(Point, Object).#add(GeoLocation).BoundGeoOperations.add(Map).BoundGeoOperations.add(Iterable).GeoOperations.add(Object, Point, Object).#add(Object, GeoLocation).GeoOperations.add(Object, Map).GeoOperations.add(Object, Iterable).RedisGeoCommands.RedisConnection.geoCommands()}.RedisConnection.geoCommands()}.Distance between from and to.Distance between from and to.Distance between from and to.Distance between member1 and member2.Distance between member1 and member2 in the given Metric.Distance between member1 and member2.Distance between member1 and member2 in the given Metric.BoundGeoOperations.distance(Object, Object).BoundGeoOperations.distance(Object, Object, Metric).GeoOperations.distance(Object, Object, Object).GeoOperations.distance(Object, Object, Object, Metric).RedisConnection.geoCommands()}.BoundGeoOperations.hash(Object[]).GeoOperations.hash(Object, Object[]).GeoIndexDefinition.GeoIndexDefinition.IndexedData implementation indicating storage of data within a Redis GEO structure.RedisConnection.geoCommands()}.Point representation of positions for the members.Point representation of positions for one or more members.Point representation of positions for one or more members.Point representation of positions for one or more members.Point representation of positions for one or more members.BoundGeoOperations.position(Object[]).GeoOperations.position(Object, Object[]).RedisConnection.geoCommands()}.RedisConnection.geoCommands()}.Circle.Circle applying given parameters.Circle applying given parameters.Circle.Circle applying RedisGeoCommands.GeoRadiusCommandArgs.Circle.Circle applying GeoRadiusCommandArgs.BoundGeoOperations.radius(Circle).#radius(Circle, GeoRadiusCommandArgs).GeoOperations.radius(Object, Circle).#radius(Object, Circle, GeoRadiusCommandArgs).RedisConnection.geoCommands()}.RedisConnection.geoCommands()}.Distance from member applying given parameters.Distance from member applying given parameters.Distance from member applying given parameters.Distance.Distance
and RedisGeoCommands.GeoRadiusCommandArgs.Distance.Distance and GeoRadiusCommandArgs.BoundGeoOperations.radius(Object, Object, double).BoundGeoOperations.radius(Object, Distance).#radius(Object, Distance, GeoRadiusCommandArgs).GeoOperations.radius(Object, Object, double).GeoOperations.radius(Object, Object, Distance).#radius(Object, Object, Distance, GeoRadiusCommandArgs).Converter capable of converting GeoRadiusResponse into GeoResults.Converter capable of convering GeoWithin into GeoResults.RedisConnection.geoCommands()}.BoundGeoOperations.remove(Object[]).GeoOperations.remove(Object, Object[]).RedisConnection.stringCommands()}.key.key.key from the hash at the bound key.begin and end.hashKey from hash at key.hashKey from hash at key.key.key between begin and end.key.key between begin and end.Supplier.ApplicationContext for the given key.ApplicationContext for the given key.MockHttpServletRequestBuilder for a GET request.MockHttpServletRequestBuilder for a GET request.null if the entry is no longer available.Context, or throw
a NoSuchElementException if the key is not present.Context.Accept header.Accept-Charset header.acceptCharset' attribute.Charsets.Access-Control-Allow-Credentials response header.Access-Control-Allow-Headers response header.Access-Control-Allow-Methods response header.Access-Control-Allow-Origin response header.Access-Control-Expose-Headers response header.Access-Control-Max-Age response header.Access-Control-Request-Headers request header.Access-Control-Request-Method request header.accesskey' attribute.action' attribute.#getActivationName() method,
returning the bean name as set on this MessageEndpointFactory.link-state is connected and flags does not contain
fail or fail?.link-state is connected and flags does
not contain fail or fail?.Map value type if the type is a Map, returns the
component type if the type TypeInformation.isCollectionLike() or the simple type if none of this applies.null if not available.HandlerInterceptor array.HTTP methods,
as specified by the Allow header.allowCredentials flag, or null if none.null if none.null in which case
only "GET" and "HEAD" allowed.null if none.supported methods also
automatically adding "OPTIONS" to the list even if not present as a supported
method.alt' attribute.AliasEvent.value of the bound key and return its old value.value of key and return its old value.value of key and return its old value.AnnotatedBeanDefinitionReader for the given bean factory.null if it's not present.null if it's not present.SmartContextLoader that supports annotated classes.List if
there're no annotations.List if there're no annotations.ApplicationContext associated with the supplied ExtensionContext.ApplicationContext, if any.ApplicationContext associated with the web application,
if it was initialized with one via
WebHttpHandlerBuilder#applicationContext.ApplicationContext.RequestMappingHandlerAdapter and the
ExceptionHandlerExceptionResolver.null if
not initialized yet via ExceptionHandlerExceptionResolver.afterPropertiesSet().null if
not initialized yet via RequestMappingHandlerAdapter.afterPropertiesSet().HttpAsyncClient used for
synchronous execution.Executor instance to be used when processing async
method invocations.WebAsyncManager for the current request, or if not
found, create and associate it with the request.WebAsyncManager for the current request, or if not
found, create and associate it with the request.HttpRequests.AsyncUncaughtExceptionHandler instance to be used
when an exception is thrown during an asynchronous method execution
with void return type.null if not found.String attribute with the given name.context ClassLoader for the
managed resources ClassLoader before allowing the invocation to occur.AnnotationAttributes of the annotation configured.context ClassLoader for the
managed resources ClassLoader before allowing the invocation to occur.autocomplete' attribute.autocomplete' attribute.Integer.MAX_VALUE.null if none.BeanNameGenerator for use with AnnotatedBeanDefinitionReader
and/or ClassPathBeanDefinitionScanner, if any.SimpleEvaluationContext does not support the use of bean references.Parameters instance with effectively all special parameters removed.BindStatus for this tag.RedisConnection.stringCommands()}.offset of value at key.offset of value at key.offset of value at key.offset of value at key.Publisher.MockClientHttpRequest.setWriteHandler(java.util.function.Function<reactor.core.publisher.Flux<org.springframework.core.io.buffer.DataBuffer>, reactor.core.publisher.Mono<java.lang.Void>>) is configured.null if not present.BootstrapContext associated with this bootstrapper.Integer.MAX_VALUELocale.ClassLoader to load resource bundles with.ByteBuffer without consuming it.Cache.Cache.CacheAwareContextLoaderDelegate to use for transparent
interaction with the ContextCache.CacheAwareContextLoaderDelegate to use for transparent
interaction with the ContextCache.CacheAwareContextLoaderDelegate to use for transparent
interaction with the ContextCache.Cache-Control header.CacheControl instance
that builds the Cache-Control HTTP response header.Callable to use for concurrent handling (never null).CallableProcessingInterceptor registered under the given key.CallableStatementCreatorFactory being usedBeanDefinitions of the repository interfaces to create repository instances for.null if not defined.charset parameter, if any.@ContextConfiguration.ClassPathBeanDefinitionScanner for the given bean factory.RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().ClientResources to reuse infrastructure.ClientResources to reuse infrastructure.Collections.unmodifiableSet(Set) of cluster nodes.PartialUpdate.UpdateCommand.ServerCodecConfigurer.cols' attribute.UNKNOWN.null).Collections or the key type for Maps.Executor that this adapter delegates to.null if not holding one.null).RedisConnection.serverCommands().RedisConnection.serverCommands().pattern from server.pattern from server.pattern from server.@Configuration
and/or @Component
classes that make up the application configuration.null if none specified.DataSource for the currently configured Quartz Scheduler,
to be used by LocalDataSourceJobStore.DataSource for the currently configured
Quartz Scheduler, to be used by LocalDataSourceJobStore.ResourceLoader for the currently configured Quartz Scheduler,
to be used by ResourceLoaderClassLoadHelper.Executor for the currently configured Quartz Scheduler,
to be used by LocalTaskExecutorThreadPool.ConfigurableWebBindingInitializer to use for
initializing all WebDataBinder instances.Configuration object for the current
web application context.ClassLoader to load repository interfaces for configuration inspection.RepositoryConfigurationSource that backs the RepositoryConfiguration.connectionType.connectionType for a specific RedisURI.Connection header.getConnectionFromDriver,
using the default username and password of this DataSource.getConnectionFromDriver,
using the given username and password.UserCredentialsDataSourceAdapter.doGetConnection(String, String),
keeping the given user credentials as-is.DataSource to be configured.null).RequestMappingInfo;
or instance with 0 consumes expressions (never null).String, using the configured
character encoding.InputStream to the cached content.Locale of the content languages,
as specified by the Content-Language header.Content-Length header.ContentNegotiationManager bean created by or registered
with the annotation-driven element.ContentNegotiationManager.ContentNegotiationManager.ContentNegotiationManager to use to determine requested media types.Content-Type header.null otherwise.WebApplicationContext from which to load the delegate Filter bean.WebApplicationContext that this servlet is supposed to use.ContextCache used by this context loader delegate.ContextCustomizerFactory instances for this bootstrapper.ContextCustomizers that will be applied
when the application context is loaded.ApplicationContextInitializer classes for the
test class.ContextLoader for the test class.ContextLoader class that was declared via
@ContextConfiguration.{}).null.ConversionService for binding JDBC values to bean properties,
or null if none.targetTimeUnit.RedisConverter in use.CorsConfiguration based on the incoming request.CorsConfiguration based on the incoming request.CorsConfiguration objects,
keyed by path pattern.CorsConfiguration objects,
keyed by path pattern.CorsProcessor.null if not defined.CronTask objects.CrudMethods meta information for the repository.class' attribute.style' attribute.RequestContextHolder.null if none set.null.null.RequestMappingInfo, or null.null.null.DataSource.DataSource with the connection properties applied.DataSource that provides the connectivity to the
embedded database.Map of DataSources maintained by this object.Date header.name.SqlParameter objects.Function.@ContextConfiguration annotation, either explicitly
or implicitly.Decoder of this reader.Decoder.ExceptionHandlerExceptionResolver.setCustomArgumentResolvers(java.util.List<org.springframework.web.method.support.HandlerMethodArgumentResolver>).Content-Type to be used for writing.ContextLoader class
to use for the supplied test class.DelegatingSmartContextLoader.WebDelegatingSmartContextLoader if the supplied class is
annotated with @WebAppConfiguration and
otherwise delegates to the superclass.MimeMessages,
or null if none.null if none.ErrorHandler implementation based on the boolean
value indicating whether the task will be repeating or not.null if none.web.xml
(if any).ExceptionHandlerExceptionResolver.setReturnValueHandlers(java.util.List<org.springframework.web.method.support.HandlerMethodReturnValueHandler>).Servlet.ExampleMatcher.StringMatcher.TestExecutionListener classes for this bootstrapper.TestExecutionListener classes for
this bootstrapper.DeferredResultProcessingInterceptor registered under the given key.RedisConnection.input type="radio"' tag.Bean from the container.Bean.Bean and allows to be specific about the type that is about to be
created.@IfProfileValue at the class-level, and
otherwise delegate to the parent implementation.null if none.Comparison.Detail.getTarget() as formatted String.Comparison.Detail.getTarget() as formatted String.dir' attribute.obj is
not null; otherwise returns an empty String.Object, HTML escaped
as required.Object, HTML escaped
as required.null if not set.null if not present.PropertyEditor for EditorAwareTag.input type="checkbox/radio"' tag.AnnotationMetadata for the @Enable annotation that triggered the configuration.Encoder of this writer.Encoder, if any.JsonEncoding for this view.enctype' attribute.#getEndpointClass() method,
returning null in order to indicate a synthetic endpoint type.ScriptEngine to use by the views.ScriptEngine.EntityInformation the repository factory is using.EntityInformation for the given domain class.EntityInformation for the given domain class.Environment associated with this filter.Environment associated with this servlet.Throwable error if any or nullSQLErrorCodes instance for the given database.SQLErrorCodes for the given DataSource,
evaluating "databaseProductName" from the
DatabaseMetaData, or an empty error codes
instance if no SQLErrorCodes were found.ETag header.EvaluationContext built using the given Parameters and parameter values.@ControllerAdvice
beans discovered in the ApplicationContext.@ExceptionHandler method for the given exception.TypeFilters to be used to exclude packages from repository scanning.TypeFilters to define which types to exclude when scanning for repositories or repository
implementations.TypeFilters to define which types to exclude when scanning for repositories.null if none specified.Async.value() at the method or declaring
class level.exception that the supplied test method is expected to throw.TimeUnit.MILLISECONDS.TimeUnit.SECONDS.key.key in seconds.key in and convert it to the given TimeUnit.Expires header.PersistentProperty that is annotated with TimeToLive.null if none.null if not field-specific.RepositoryConfigurationExtension for store specific callbacks and BeanDefinition
post-processing.RedisSystemException wrapping the given Exception.HttpServletRequest.getLocale().null.QName object.field object on the
specified target object.Formatter-declared field type.java.io.File,
i.e. to a file in the file system.java.io.File,
i.e. to a file in the file system.java.io.File,
i.e. to a file in the file system.java.io.File,
i.e. to a file in the file system.java.io.File,
i.e. to a file in the file system.ServletContext.getRealPath, throwing a FileNotFoundException
if not found or not resolvable.null if it does not exist.org.apache.commons.fileupload.FileItem
instance.org.apache.commons.fileupload.disk.DiskFileItemFactory
instance.Map of the multipart files contained in this request.null if not defined.Iterator of String objects containing the
parameter names of the multipart files contained in this request.mappings property.FileTypeMap used by this MimeMessageHelper.org.apache.commons.fileupload.FileUpload
instance.null.Pair.IllegalArgumentException
if the value cannot be parsed as a date.null if there is no value, or raise IllegalArgumentException
if the value cannot be parsed as a date.IntervalTask objects.IntervalTask objects.FlashMapManager instance to save flash attributes.AbstractFlashMapManager.retrieveFlashMaps(javax.servlet.http.HttpServletRequest) and AbstractFlashMapManager.updateFlashMaps(java.util.List<org.springframework.web.servlet.FlashMap>, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse),
The default implementation returns a shared static mutex.null if not present.true if this collection is in flow style, false
for block style.id' attribute.ResourceResolver chain of the matched
ResourceHttpRequestHandler to resolve the URL path to expose for
public use.DateTimeFormatter.formatter.formatter.DateTimeFormatter."application/x-www-form-urlencoded" or an empty map otherwise.ResourceUrlProvider.getForLookupPath(String) that accepts a full request
URL path (i.e. including context and servlet path) and returns the full request
URL path to expose for public use.Gson instance for this converter.NotificationBroadcaster when notifying
any NotificationListener.HandlerExecutionChain for the given handler, including
applicable interceptors.null if no
specific one is found.ApplicationContext is refreshed.null in case
of no registrations.HandlerMapping beans that were detected by
type in the WebApplicationContext or initialized based on the
default set of strategies from DispatcherServlet.properties.null if none.HttpHeaders backing header related accessor methods,
allowing for populating selected header entries.RequestMappingInfo;
or instance with 0 header expressions (never null).null if none.Host header.HttpComponentsAsyncClientHttpRequestFactory.getAsyncClient()HttpClient used for
synchronous execution.HttpClient instance that this request executor uses.HttpEntity for the given part Object.DefaultResponseErrorHandler.handleError(ClientHttpResponse, HttpStatus)id' attribute.If-Match header.If-Modified-Since header.If-None-Match header.If-Unmodified-Since header.true if the tag can be omitted while this collection is
emitted.TypeFilters to define which types to include when scanning for repositories.Parameters.IndexDefinition for a given keyspace.String representation of the index name.@InitBinder methods, or possibly
null if not initialized yet via RequestMappingHandlerAdapter.afterPropertiesSet().ApplicationContextInitializer classes that were declared via
@ContextConfiguration.InputStream to retrieve the data in this OutputStream.ServletContext.getResourceAsStream,
but throws a FileNotFoundException if no resource found.Types to be used for insert.ObjectName instance corresponding to the supplied name.ObjectName instance corresponding to the supplied name.ObjectName instance for the specified domain and a
single property with the supplied key and value.ObjectName instance with the specified domain name
and the supplied key/name properties.ClassLoader that supports instrumentation
through AspectJ-style load-time weaving based on user-defined
ClassFileTransformers.HandlerInterceptor reference.HandlerMapping instances with.null if not present.RepositoryInvoker for a repository managing the given domain type.IsNewStrategy to be used for the given type.null if none.input type="checkbox/radio"' tag.option' tag.itemLabel' attribute.Collection, Map or array of objects
used to generate the 'input type="checkbox/radio"' tags.items' attribute.value' attribute
of the 'input type="checkbox/radio"' tag.value'
attribute of the 'option' tag.itemValue' attribute.JavaType for the specific class.JavaType for the specified type and context class.JAXBContext for the given class.JdbcTemplate itself, if available,
in particular for passing it on to other JdbcTemplate consumers.JdbcTemplate.JdbcTemplate.JdbcTemplate used by this operation object.Jsonb instance for this converter.timeout from the @Test
annotation on the supplied test method.RedisClusterNode that is the current master serving the given key.KeyspaceConfiguration.KeyspaceSettings for given type.Part.Type.label' attribute.<option> tag.lang' attribute.Last-Modified header.getLastModified method.getLastModified method.HandlerMethod.HttpServlet.getLastModified(HttpServletRequest).UNKNOWN.LobCreator instance, i.e. a session for creating BLOBs
and CLOBs.LinkedCaseInsensitiveMap.null).LocaleContext using the configured
LocaleContextResolver.LocaleContextResolver.Location header.@ContextConfiguration.ApplicationContext
configuration files for the test class.List of Resource locations.Logger.Logger, backed by SLF4J if present on the classpath or falling back
to java.util.logging.Logger.null if not present.List of MethodLookup.MethodPredicate.ManagedAttribute
if the supplied Method has the corresponding metadata.ManagedMetric
if the supplied Method has the corresponding metadata.ManagedNotifications
if the supplied the Class has the corresponding metadata.ManagedOperation
if the supplied Method has the corresponding metadata.ManagedOperationParameter
if the supplied Method has the corresponding metadata.ManagedResource
if the supplied Class has the appropriate metadata.null if none specified.MappedInterceptors as an array.GET requests onto specific handler
methods.MappingConfiguration used.RequestMapping annotations to create
the RequestMappingInfo.RequestMappingInfo.Map.Marshaller used by this MarshallingSource.HandlerMapping that would handle the given request and
return it as a MatchableHandlerMapping that can be used to test
request-matching criteria.null otherwise.null otherwise.PathMatcher.getPatternComparator(String).maxAge value, or null if none.max boundary of the expected count range.BackOffExecution.nextBackOff() returns BackOffExecution.STOP.lastAccessTime before a session expires.maxlength' attribute.ModelMBeanInfoSupport class supplied with all
JMX implementations and populates the metadata through calls to the subclass.MediaType in this case for a given
Resource.PathExtensionContentNegotiationStrategy.getMediaTypeForResource(org.springframework.core.io.Resource)
with the ability to also look up through the ServletContext.MediaType for the given HttpServletRequest.MessageCodesResolver.MessageCodesResolver for building message codes
from data binding and validation error codes.MessageCodesResolver for building message codes
from data binding and validation error codes.HttpMessageConverters used by the
RequestMappingHandlerAdapter and the
ExceptionHandlerExceptionResolver.AbstractRequestLoggingFilter.createMessage(HttpServletRequest, String, String) when
AbstractRequestLoggingFilter.isIncludePayload() returns true.RepositoryMetadata for the given repository interface.Method with the given name and parameters declared on the given type, if available.IllegalStateException).method' attribute.null).MethodParameter to be used to potentially qualify the paging and sorting request parameters to.MethodParameter associated with this error, if any.MethodResolver delegates, if any.name.RequestMethods contained in this condition.RequestMappingInfo;
or instance with 0 request methods (never null).String[] representing the argument signature of a
method.min boundary of the expected count range.MockHttpServletResponse, unwrapping
HttpServletResponseWrapper decorators if necessary.MODEL_KEY_PREFIX + objectName'
and the object itself.MODEL_KEY_PREFIX + objectName'
and the object itself as 'objectName'.ModelAndView prepared by the handler.ModelAndViewResolvers, or null.ModelMap instance (never null).null if not defined.MultiValueMap of the multipart files contained in this request."multipart/form-data" or an empty map otherwise.multiple' attribute rendered
on the final 'select' element.Param annotation).null if not defined.null if anonymous.@ContextConfiguration.null.name' attribute.name' attribute.name' attribute.name' attribute.#getName() to always return null,
because the 'name' attribute is not supported by the
'label' tag.Logger instance.@ModelAttribute parameter annotation (if present) or falling
back on parameter type based conventions.ModelAttribute annotation value
the declared return type if it is more specific than Object
the actual return value type
null.Errors object.NestedPathTag.null if none.AbstractSequenceMaxValueIncrementer.getSequenceQuery().RedisClusterNodes.OutputStream that ignores all data given to it.NotificationFilter associated
with the encapsulated NotificationListener.ManagedNotification metadata from the Class of the managed resource
and generates and returns the corresponding ModelMBeanNotificationInfo metadata.NotificationListener.Methods parameters.ObjectMapper for this view.ObjectMapper for this view.ObjectName for a bean.ObjectName based on the identity
of the managed resource.ObjectName via the given key, trying to
find a mapped value in the mappings first.ObjectName from the source-level metadata associated
with the managed resource's Class.ObjectName for the supplied bean.ObjectName for the implementing object.ObjectWrapper, or the
default wrapper if none specified.onblur' attribute.onchange' attribute.onclick' attribute.ondblclick' attribute.onfocus' attribute.onkeydown' attribute.onkeypress' attribute.onkeyup' attribute.onmousedown' attribute.onmousemove' attribute.onmouseout' attribute.onmouseover' attribute.onmouseup' attribute.onreset' attribute.onselect' attribute.onselect' attribute.onsubmit' attribute.Method from the
metadata.MBeanParameterInfo from the ManagedOperationParameter
attributes attached to a method.StandardOperatorOverloader.MappingJacksonValue value container (for providing
additional serialization instructions) or simply cast it if already wrapped.Context.5000.Ordered.LOWEST_PRECEDENCE,
thereby ensuring that custom listeners are ordered after default
listeners supplied by the framework.2000.1500.3000.4000.1000.ControllerAdvice
annotation, or Ordered.LOWEST_PRECEDENCE otherwise.Context.Origin header.Page based on the given content, Pageable and Supplier applying
optimizations.Pageable of the parameters, if available.Pageable Method parameter if available.MethodParameter we tried to convert the source value for.null if none.null in order to skip parameter detection).Pageable information in.Parameters instance backing the accessor.Parameters wrapper to gain additional information about Method parameters.TypeInformations for the parameters of the given Constructor.TypeInformations for the parameters of the given Method.null if none.RequestMappingInfo;
or instance with 0 parameter expressions (never null).MergedContextConfiguration for the parent application context
in a context hierarchy.ApplicationContext for the context defined by this
MergedContextConfiguration from the context cache.null if none.fieldType
annotated with annotation.RedisPassword defined.null if not set.resolved property path for the
form object.PathMatchConfigurer.null if none.PathMatcher.Comparator suitable for sorting patterns in order of
explicitness.Comparator suitable for sorting patterns
in order of explicitness for that path.RequestMappingInfo;
or instance with 0 patterns (never null).PersistentEntity managed by the underlying repository.PersistentEntity for the given domain class.Pragma header.FluxPreparedStatementCreator based on the given SQL and named parameters.PreparedStatementCreator based on the given SQL and named parameters.Principal instance containing the name of the
authenticated user.fieldType annotated with
annotation.RequestMappingInfo;
or instance with 0 produces expressions (never null).MediaType.ALL
ProjectionFactory to be used with the repository instances created.JndiLocatorDelegate.null if bound to an object rather than a specific property.BeanWrapper that this instance uses.PropertyAccessor delegates, if any.PropertyEditor, if any, in use for value bound to this tag.null.PropertySources
for the test class.PropertySource properties for the
test class.ExampleMatcher.PropertySpecifier for given path.ExampleMatcher.PropertySpecifiers of the underlying ExampleMatcher.q parameter, if any.QueryLookupStrategy for the given QueryLookupStrategy.Key and EvaluationContextProvider.QueryLookupStrategy from eventually.QueryLookupStrategy.Key to define how query methods shall be resolved.QueryMethod.QueryMethods declared for that repository.QueryMethods contained in the repository managing the given domain class.RedisConnection.stringCommands()}.key between start and end.key between start and end.Range header.HttpStatus enum) as an integer.HttpStatus enum) as an integer.ClassTypeInformation to represent the TypeInformation of the raw type of the current
instance.MediaType's that this reader supports.null if not defined.null or empty).Types type for columns that return ResultSets as ref cursors
if this feature is supported.ConcurrentReferenceHashMap.Reference to the ConcurrentReferenceHashMap.Entry for the specified key,
or null if not found.ObjectNames of all registered beans.@Repeat
annotation on the supplied method.Repositories that were populated.RepositoryComposition.RepositoryFragments with #getRepository(Class, RepositoryFragments) to
compose repositories backed by custom implementations.Optional.empty() if the store specific defaults
shall be applied.RepositoryConfiguration instance for the given RepositoryConfigurationSource and
interface name.RepositoryConfigurations obtained through the given RepositoryConfigurationSource.Optional.empty() if not defined in the source.RepositoryComposition.RepositoryFragments based on RepositoryMetadata to add repository-specific extensions.RepositoryInformation to determine meta-information about the repository being used.RepositoryInformation for the given RepositoryMetadata and custom
RepositoryComposition.RepositoryFragments.RepositoryInformation for the given repository interface.RepositoryInformation for the given domain class.RepositoryMetadata for the given repository interface.MockFilterChain.doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse) has been called with.HttpServletRequest that we're wrapping.byte[]."requestDataValueProcessor".InterceptingClientHttpRequestFactory
if necessary.ResourceHttpRequestHandler instance.AbstractView.renderMergedOutputModel(java.util.Map<java.lang.String, java.lang.Object>, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse), i.e. to the view.Map value type if the type is a Map, returns the
component type if the type TypeInformation.isCollectionLike() or the simple type if none of this applies.IllegalArgumentException.IllegalArgumentException.Collections, the key type for Maps or the single
generic type if available.RedisConnectionFactory or throws IllegalStateException if the connection
factory is not set.Map or throw
IllegalStateException if the map value type cannot be resolved.IllegalArgumentException if
the type information cannot be resolved.RepositoryInformation for the given domain type.TypeInformation for the given raw super type.IllegalArgumentException if no field could be found.WebApplicationContext for this web app, typically
loaded via ContextLoaderListener.WebApplicationContext for this web app, typically
loaded via ContextLoaderListener.MessageSource.Publisher body.HandlerExceptionResolver.HandlerMethod.createWithResolvedBean().ObjectName String representations for
which the encapsulated NotificationFilter will
be registered as a listener for Notifications.ResourceResolverChain that was used to resolve the
Resource being transformed.Resource to load the
script from.@WebAppConfiguration.MockServletContext.ApplicationContext resource locations
when detecting default locations.AnnotationConfigContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.GenericGroovyXmlContextLoader supports both Groovy and XML
resource types for detection of defaults.-context.properties"."-context.xml" in order to support detection of a
default XML config file.AnnotationConfigWebContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.GenericGroovyXmlWebContextLoader supports both Groovy and XML
resource types for detection of defaults."-context.xml" in order to support detection of a
default XML config file.ApplicationContext resource locations
when detecting default locations."-context.xml" and "Context.groovy" in order to
support detection of a default XML config file or Groovy script."-context.xml" and "Context.groovy" in order to
support detection of a default XML config file or Groovy script.ResourceUrlProvider.MockFilterChain.doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse) has been called with.HttpServletResponse that we're wrapping (if any).Flux<T> of decoded elements.byte[].byte[].RestTemplate for the gateway.null if the result wasn't set.ResultProcessor to be used with the query method.javax.sql.rowset.CachedRowSet).Method.ReturnedType.TypeInformation for the return type of the given Method.RequestMappingHandlerAdapter and the
ExceptionHandlerExceptionResolver.null if not
initialized yet via ExceptionHandlerExceptionResolver.afterPropertiesSet().null if not
initialized yet via RequestMappingHandlerAdapter.afterPropertiesSet().RollbackRuleAttribute objects
(never null).ContextLoaderListener is being created with.null if none.rows' attribute.Scheduled methods
as well as from programmatic SchedulingConfigurer interaction.TaskScheduler instance for this registrar (may be null).String.ScopeMetadataResolver for use with AnnotatedBeanDefinitionReader
and/or ClassPathBeanDefinitionScanner, if any.BshScriptUtils.Pair.Collections.unmodifiableSet(Set) of Sentinels.MBeanServer that the beans will be registered with.DispatcherServlet is being created with.ServletConfig to be injected or null.ServletContext to be injected or null.ServletContext.DispatcherServlet.DispatcherServlet —
for example "/", "/app", etc.ServletHttpHandlerAdapter.null when no
ServletConfig set yet.DispatcherServlet will be registered.ServletHttpHandlerAdapter.init(ServletConfig).null.action' attribute.HttpServletRequest this object is based on.HttpServletResponse this object is based on.Session,
lazily initializing it if hasn't been specified explicitly.HttpSession that we're wrapping.WebSession for the given exchange.WebSessionIdResolver.WebSessionManager.SessionStatus instance to use that can be used to
signal that session processing is complete.WebSessionStore.RedisConnection.stringCommands()}.value of key and return its old value.value of key and return its old value.LettuceConnections should share a single native connection.DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType) that describes the "thing" that has been compared so
users know how to locate it.DatabaseMetaData.supportsGetGeneratedKeys()?TableMetaDataContext.getSimpleQueryForGetGeneratedKey(java.lang.String, java.lang.String)null if not defined.size' attribute.size' attribute.RedisClusterNode.SlotRange.RedisClusterNodes (master and slave) serving s specific slot.Sort specification parsed from the source.Sort Method parameter if available.RepositoryConfiguration.null).null which means this is a general purpose accessor.timeout from the
@Timed annotation
on the supplied test method.RdbmsOperation.setSql(java.lang.String) method or in a subclass constructor.null).null if not set.null.SimpleMappingExceptionResolver.setStatusCodes(Properties).ContentNegotiationStrategy of the given type.VersionStrategy for the request path of the requested resource.AntPathMatcher.AntPathStringMatcher for the given pattern.ExampleMatcher.StringMatcher for a given path or return the default one if none defined.null if not present.Source for the XSLT template under the configured URL.TypeInformation for the given raw super type.HttpMethod instances,
or null if not known.MediaType objects supported by this converter.null if not known.Tuples.Tuples.Tuples.Tuples.Tuples.Tuples.Tuples.Tuples.tabindex' attribute.TaglibFactory used to enable JSP tags to be
accessed from FreeMarker templates.%TAG directive.target' attribute."targetBeanName" feature."targetBeanName" feature.candidate object.RepositoryInformation using
reflection.RepositoryInformation using
reflection.null if none specified).null).MarkupTemplateEngine for the current
web application context.MergedContextConfiguration.TestContext managed by this TestContextManager.TestContextManager associated with this runner.TestExecutionListeners
for the test class in the BootstrapContext associated with this bootstrapper.TestExecutionListeners
registered for this TestContextManager.null).null.null for the default group).SimpleThrowawayClassLoader.ClassLoader, enabling classes to be
loaded and inspected without affecting the parent ClassLoader.SimpleThrowawayClassLoader.null if no timeout is set.TimeToLiveAccessor associated with the entity.null if none derivable from the request).title' attribute.ClusterTopology.null if the method is non-transactional.close calls to ConnectionFactoryUtils.close() calls to DataSourceUtils.null if unknown.TriggerTask objects.Parameter.null if not defined.type' attribute.type' attribute.password' causing the rendered HTML 'input'
element to have a 'type' of 'password'.SignalType.ON_SUBSCRIBE,
SignalType.ON_NEXT, SignalType.ON_ERROR, or
SignalType.ON_COMPLETETypeInformation for the type arguments of the current TypeInformation.StandardTypeComparator.TypeConverter.MethodInvoker.getTypeDifferenceWeight(Class[], Object[]) but operates on TypeDescriptors.SimpleEvaluationContext does not support use of type references.candidate
object, unwrapping not only a top-level proxy but also any number of
nested proxies.Upgrade header.java.net.URL.ServletContext.getResource,
but throws a FileNotFoundException if no resource found.UrlPathHelper.UrlPathHelper.UrlPathHelper.Validator.Validator instead of the one created by default.Validator instead of the one created by default.null).null if not field-specific.value' attribute.value' attribute.<option> tag.DefaultComparisonFormatter.getShortString(org.w3c.dom.Node, java.lang.String, org.xmlunit.diff.ComparisonType) based on the comparison type.multiply operator directly here for certain types
of supported operands and otherwise delegates to any registered overloader
for types not supported here.ExampleMatcher.NoOpPropertyValueTransformer if none
defined.Expression.setValue(java.lang.Object, java.lang.Object)
method using the default context.Expression.setValue(Object, Object) method using the default context.Expression.setValue(EvaluationContext, Object) method for the given context.Expression.setValue(EvaluationContext, Object, Object) method for the given
context.Class' type of the field.Expression.setValue(java.lang.Object, java.lang.Object)
method using the default context.Expression.setValue(Object, Object) method using the default context.Expression.setValue(EvaluationContext, Object) method for the given context.Expression.setValue(EvaluationContext, Object, Object) method for the given
context.null if we using a view name
to be resolved by the DispatcherServlet via a ViewResolver.null if we are using a view name
to be resolved by the DispatcherServlet via a ViewResolver.null if we are using a view name
to be resolved by the DispatcherServlet via a ViewResolver.null if a View object is set.null if we are using a View object.null if using a
View instance.HttpServletRequest into a view name.HttpServletRequest
into the view name based on the configured parameters.ViewResolver.WebApplicationContext to use.WebApplicationContext for this web app, typically
loaded via ContextLoaderListener.WebApplicationContext for this web app.WebApplicationContext reference to expose.WebApplicationContext for this web app, typically
loaded via ContextLoaderListener.null if none.WebClient.WebConnection for the WebClient.AbstractWebArgumentResolverAdapter.supportsParameter(org.springframework.core.MethodParameter).MediaType's that this writer supports.null.XMLEventReader for the given StAX Source.XMLEventWriter for the given StAX Result.SmartContextLoader that supports XML configuration
files and/or Groovy scripts.XMLStreamReader for the given StAX Source.XMLStreamWriter for the given StAX Result.LoadTimeWeaver implementation for GlassFish's
org.glassfish.api.deployment.InstrumentableClassLoader InstrumentableClassLoader.GlassFishLoadTimeWeaver class using
the default class loader.GlassFishLoadTimeWeaver class using
the supplied ClassLoader.ApplicationContextInitializer classes to use
for initializing all web application contexts in the current application: "globalInitializerClasses"MarkupTemplateEngine for automatic lookup in a web environment.groovy.text.markup.TemplateConfiguration and
an implementation of Spring MVC's GroovyMarkupConfig for creating
a MarkupTemplateEngine for use in a web application.AbstractTemplateView subclass based on Groovy XML/XHTML markup templates.GroovyMarkupView (i.e.view class to GroovyMarkupViewResolver.requiredViewClass():
by default GroovyMarkupView.GroovyScriptFactory to allow the customization of
a created GroovyObject.ScriptEvaluator strategy interface.ScriptFactory implementation
for a Groovy script.WebApplicationContext implementation which takes
its configuration from Groovy bean definition scripts and/or XML files, as understood by
an GroovyBeanDefinitionReader.GsonBuilder
which Base64-encodes byte[] properties when reading and writing JSON.GsonBuilder which Base64-encodes byte[]
properties when reading and writing JSON.FactoryBean for creating a Google Gson 2.x Gson instance.HttpMessageConverter
that can read and write JSON using the
Google Gson library.GsonHttpMessageConverter with default configuration.GsonHttpMessageConverter with the given delegate.ResourceResolver that delegates to the chain to locate a resource
and then attempts to find a variation with the ".gz" extension.DataFieldMaxValueIncrementer that retrieves the next value
of a given H2 sequence.CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given SAP HANA sequence.MvcResult details.HandlerMethod.Flux by calling a biconsumer with the
output sink for each onNext.Mono by calling a biconsumer with the
output sink for each onNext.BindingResult.WebDataBinder conversion cannot occur.DefaultResponseErrorHandler.handleError(ClientHttpResponse, HttpStatus) with the response status code.ResponseErrorHandler.handleError(ClientHttpResponse) with extra
information providing access to the request URL and HTTP method.Callable task completes.DeferredResult has been set.true by default allowing other interceptors
to be given a chance to handle the error.Accept header.MappingMediaTypeFileExtensionResolver.lookupMediaType(java.lang.String).@Valid such as
an RequestBody or RequestPart argument fails validation.MultipartFile,
or a javax.servlet.http.Part argument is required but is missing.AbstractNamedValueMethodArgumentResolver.resolveName(String, MethodParameter, NativeWebRequest)
returned null and there is no default value.AbstractNamedValueMethodArgumentResolver.resolveName(String, MethodParameter, NativeWebRequest)
returned null and there is no default value.handleNavigation method
delegates to the overloaded variant, passing in constructor-injected
NavigationHandler as argument.handleNavigation variant with explicit NavigationHandler
argument.ServletContext.getMimeType(String)
and also delegate to base class for a potential
MediaTypeFactory lookup.AbstractUrlViewController.getViewNameForRequest(javax.servlet.http.HttpServletRequest).ResponseErrorHandler if necessary.ModelAndViewContainer.ModelAndViewContainer.setRequestHandled(boolean) flag to true
to indicate the response has been handled directly.HandlerMethodReturnValueHandlers and invoke the one that supports it.HandlerExceptionResolverComposite containing a list
of exception resolvers obtained either through
WebMvcConfigurationSupport.configureHandlerExceptionResolvers(List) or through
WebMvcConfigurationSupport.addDefaultHandlerExceptionResolvers(List).HandlerExceptionResolver that delegates to a list of other HandlerExceptionResolvers.JsonSerializer, JsonDeserializer,
KeyDeserializer, TypeResolverBuilder and TypeIdResolver).AsyncHandlerInterceptor interface,
for simplified implementation of pre-only/post-only interceptors.HandlerMapping that would
serve a specific request.ApplicationContextAware.HandlerMappingIntrospector.setApplicationContext(org.springframework.context.ApplicationContext)BeanFactory.HandlerMethodArgumentResolvers.HandlerMethodReturnValueHandlers.Callable task completes.DeferredResult has been set.true by default allowing other interceptors
to be given a chance to handle the timeout.WebDataBinder conversion error occurs.Tag has any ancestor tag
of the supplied type.BeanDefinitionRegistry already contains a bean of the given type assuming the
bean name has been autogenerated.BeanDefinitionRegistry already contains a bean of the given type assuming the
bean name has been auto-generated.AbstractMessageEndpointFactory.AbstractMessageEndpoint.beforeDelivery(java.lang.reflect.Method) method of this endpoint
has already been called.ContextConfigurationAttributes instance has
class-based resources.MergedContextConfiguration instance has
class-based resources.Subscriber is actively subscribedSubscriber is actively subscribedFlux sequence is
equal to the provided value.Mono has an element.Flux sequence has at least one element.DefaultResponseErrorHandler.hasError(HttpStatus) with the response status code.DefaultResponseErrorHandler.hasError(ClientHttpResponse).ContextConfigurationAttributes instance excluding the
name.MergedContextConfiguration excluding the
test class.WebMergedContextConfiguration excluding the
test class.toString()'s hash code.ReactiveHashCommands.RedisHashCommands.RedisSerializationContext.SerializationPair.RedisElementReader and RedisElementWriter.RedisSerializationContext.SerializationPair given a RedisSerializer.RedisSerializationContext.SerializationPair.RedisElementReader and RedisElementWriter.RedisSerializationContext.SerializationPair given a RedisSerializer.keyspace.keyspace and property path.content
and assert that a value, possibly null, exists.null, exists.null, exists.key exists at the bound key.hashKey exists.hashKey exists.key exists.key exists.Context.null and not the empty String.null and not the empty String.Assert.hasLength(String, String)CharSequence is neither null nor
of length 0.String is neither null nor of length 0.ContextConfigurationAttributes instance has
path-based resource locations.MergedContextConfiguration instance has
path-based context resource locations.Method by name and exact parameters.Parameters was created for contains a Pageable argument.Method has a parameter of the given type.ExampleMatcher contains a ExampleMatcher.PropertySpecifier for the given path.ContextConfigurationAttributes instance has
either path-based resource locations or class-based resources.MergedContextConfiguration instance has
either path-based context resource locations or class-based resources.true if the DeferredResult has been set.SessionAttributes annotation.KeyspaceConfiguration.KeyspaceSettings are available for given type.Parameters was created for contains a Sort argument.Pageable, Sort).ScheduledTaskRegistrar has any tasks registered.null and must contain at least one non-whitespace character.null and must contain at least one non-whitespace character.Assert.hasText(String, String)CharSequence contains actual text.String contains actual text.ModelAndView has a view, either
as a view name or as a direct View instance.PagedResourcesAssembler and PagedResourcesAssemblerArgumentResolver.PageableHandlerMethodArgumentResolver that also supports enhancing URIs using Spring HATEOAS
support.HateoasSortHandlerMethodArgumentResolver.HateoasPageableHandlerMethodArgumentResolver using the given
HateoasSortHandlerMethodArgumentResolver..SortHandlerMethodArgumentResolver that also supports enhancing URIs using Spring HATEOAS
support.RedisConnection.hashCommands()}.fields.fields.MockHttpServletRequestBuilder for a HEAD request.MockHttpServletRequestBuilder for a HEAD request.ContentNegotiationStrategy that checks the 'Accept' request header.HttpHeaders.HttpHeaders.RequestMapping.headers().WebSessionIdResolver.MethodInterceptor for accessing a Hessian service.FactoryBean for Hessian proxies.RedisConnection.hashCommands()}.field exists.field exists.RedisConnection.hashCommands()}.field from hash at key.field from hash at key.RedisConnection.hashCommands()}.key.key.Filter that converts posted method parameters into HTTP methods,
retrievable via HttpServletRequest.getMethod().WebFilter that converts posted method parameters into HTTP methods,
retrievable via HttpRequest.getMethod().<hidden> tag renders an HTML 'input' tag with type 'hidden' using
the bound value.Flux instance.Mono instance.ParallelFlux and its Subscription
as well.RedisConnection.hashCommands()}.RedisConnection.hashCommands()}.value of a hash field by the given delta.value of a hash field by the given delta.value of a hash field by the given delta.value of a hash field by the given delta.RedisConnection.hashCommands()}.key.key.key.key.RedisConnection.hashCommands()}.fields from hash at key.fields from hash at key.RedisConnection.hashCommands()}.hasheshashesBaseSubscriber.cancel() method.Host header field name.null to clear the host of this builder.WebRequestMatcher that allows matching on the host and optionally
the port of WebRequest#getUrl().HostRequestMatcher for the given hosts —
for example: "localhost", "example.com:443", etc.RedisConnection.hashCommands()}.Cursor to iterate over entries in hash at key.Cursor to iterate over entries in hash at key.RedisConnection.hashCommands()}.value of a hash field.value of a hash field.RedisConnection.hashCommands()}.value of a hash field only if field does not exist.value of a hash field only if field does not exist.DataFieldMaxValueIncrementer that increments the maximum value of a given HSQL table
with the equivalent of an auto-increment column.DataFieldMaxValueIncrementer that retrieves the next value
of a given HSQL sequence.TableMetaDataProvider.web.xml): "defaultHtmlEscape".<htmlEscape> tag sets default HTML escape value for the current
page.RestTemplate
and other HTTP accessing gateway helpers, defining common properties
such as the ClientHttpRequestFactory to operate on.HttpClientErrorException based on
an HttpStatus.HttpClientErrorException based on
an HttpStatus and status text.HttpClientErrorException based on
an HttpStatus, status text, and response body content.HttpClientErrorException based on
an HttpStatus, status text, and response body content.HttpComponentsAsyncClientHttpRequestFactory
with a default HttpAsyncClient and HttpClient.HttpComponentsAsyncClientHttpRequestFactory
with the given HttpAsyncClient instance and a default HttpClient.HttpComponentsAsyncClientHttpRequestFactory
with the given CloseableHttpAsyncClient instance and a default HttpClient.HttpComponentsAsyncClientHttpRequestFactory
with the given HttpClient and HttpAsyncClient instances.HttpComponentsAsyncClientHttpRequestFactory
with the given CloseableHttpClient and CloseableHttpAsyncClient instances.ClientHttpRequestFactory implementation that
uses Apache HttpComponents
HttpClient to create requests.HttpComponentsClientHttpRequestFactory
with a default HttpClient.HttpComponentsClientHttpRequestFactory
with the given HttpClient instance.HttpInvokerRequestExecutor implementation that uses
Apache HttpComponents HttpClient
to execute POST requests.HttpClient that uses a default org.apache.http.impl.conn.PoolingClientConnectionManager.HttpClient instance.HttpEntity.HttpEntity with the given body and no headers.HttpEntity with the given headers and no body.HttpEntity with the given body and headers.HttpEntity and RequestEntity method argument values
and also handles HttpEntity and ResponseEntity return values.ContentNegotiationManager.HttpEntity method arguments.HttpEntity and handling
ResponseEntity.HttpHandler rather
than making actual requests to a network socket.HttpHandler to handle requests with.HttpHeaders object.HttpHeaders return values.ServerHttpResponse decorator for HTTP HEAD requests.MethodInterceptor for accessing an
HTTP invoker service.FactoryBean for HTTP invoker proxies.HttpMessageConverter implementations when a conversion attempt fails.T.HttpMessageConverterExtractor with the given response
type and message converters.HttpMessageConverterExtractor with the given response
type and message converters.Decoder exposing extra methods relevant in the context
of HTTP request or response body decoding.Encoder exposing extra methods relevant in the context
of HTTP request or response body encoding.HttpMessageConverter implementations when the
HttpMessageConverter.read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage) method fails.HttpMessageConverter implementations when the
HttpMessageConverter.write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage) method fails.ReactiveHttpInputMessage and decoding
the stream of bytes to Objects of type <T>.<T> and writing
the encoded stream of bytes to an ReactiveHttpOutputMessage.Filter that makes form encoded data available through
the ServletRequest.getParameter*() family of methods during HTTP PUT
or PATCH requests."Range" header.HttpRequestHandlerAdapter for processing requests
with HttpRequestHandlers.HttpRequestHandler
interface with the generic DispatcherServlet.HttpRequestHandler bean defined
in Spring's root web application context.HttpRequest interface
that can be overridden to adapt the request.HttpRequest wrapping the given request object.Resource to be written to an
HTTP response.HttpServerErrorException based on
an HttpStatus.HttpServerErrorException based on
an HttpStatus and status text.HttpServerErrorException based on
an HttpStatus, status text, and response body content.HttpServerErrorException based on
an HttpStatus, status text, and response body content.HttpServlet which treats
its config parameters (init-param entries within the
servlet tag in web.xml) as bean properties.HttpStatus.HttpStatus.HttpStatus and status text.HttpStatus, status text, and content.HttpStatus, status text, content, and
a response charset.WebHandler to the HttpHandler contract.RedisConnection.hashCommands()}.field.field.id field.id field of this event, if available.ObjectName with the
identity hash code of its corresponding managed resource.ObjectNamingStrategy interface that
creates a name based on the identity of a given instance.(UUIDs).If-Match header field name.If-Modified-Since header field name.If-None-Match header field name.If-Range header field name.If-Unmodified-Since header field name.NXBiConsumer if all given Optional are present.If-Modified-Since header.If-Modified-Since header.If-Modified-Since header.If-None-Match header.If-None-Match header.If-None-Match header.XXIf-Unmodified-Since header.ParameterMetaData.getParameterType(int)
completely, i.e. to never even attempt to retrieve PreparedStatement.getParameterMetaData()
for StatementCreatorUtils.setNull(java.sql.PreparedStatement, int, int, java.lang.String) calls.Mono that ignores elements from the source (dropping them),
but completes when the source completes.DROP statement within an executed
script can be ignored.image/gif.image/gif.MediaType.IMAGE_GIF.MimeTypeUtils.IMAGE_GIF.image/jpeg.image/jpeg.MediaType.IMAGE_JPEG.MimeTypeUtils.IMAGE_JPEG.image/png.image/png.MediaType.IMAGE_PNG.MimeTypeUtils.IMAGE_PNG.RepositoryFragment backed by the implementation object.RepositoryFragment.ImplementedRepositoryFragment for the given interface class and implementation.beans map of the
MBeanExporter.RedisGeoCommands.GeoRadiusCommandArgs.Flag.WITHCOORD flag to also return the longitude, latitude coordinates of the matching items.RedisGeoCommands.GeoRadiusCommandArgs.Flag.WITHDIST flag to also return the distance of the returned items from the specified center.Method is declared in
one of the configured interfaces and that it is public.true.Method is declared in
one of the configured interfaces and that it is public.true.MediaType includes the given media type.Method is declared in
one of the configured interfaces and that it is public.true.RedisConnection.stringCommands()}.ReactiveNumberCommands.HIncrByCommand given a key.ReactiveNumberCommands.IncrByCommand given a key.key by 1.key by 1.RedisConnection.stringCommands()}.RedisConnection.stringCommands()}.key by delta.key by delta.key by delta.key by delta.value of a hash key by the given delta at the bound key.value of a hash key by the given delta at the bound key.delta.delta.value of a hash hashKey by the given delta.value of a hash hashKey by the given delta.value of a hash hashKey by the given delta.value of a hash hashKey by the given delta.key by delta.key by delta.value in sorted set by increment.value in sorted set by increment.value in sorted set by increment.SerializationFeature.INDENT_OUTPUT option.index form list at the bound key.index form list at key.index form list at key.Flux
of Tuple2<(index, value)>.I using the provided BiFunction,
returning a Flux<I>.IndexConfiguration allows programmatic setup of indexes.IndexConfiguration.IndexDefinition allow to set up a blueprint for creating secondary index structures in Redis.IndexDefinitionProvider give access to IndexDefinitions for creating secondary index structures.IndexDefinition.IndexedData represents a secondary index for a property path in a given keyspace.ReactiveZSetCommands.ZRankCommand given a member to obtain its rank (ordering low to high).IndexResolver extracts secondary index structures to be applied on a given path, PersistentProperty
and value.Converter implementation that is used to transform values for usage in a particular secondary index.RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().selection.selection.selection.@InitBinder methods.PathResourceResolver among the configured resource
resolvers and set its allowedLocations property (if empty) to
match the locations configured on this class.WebApplicationObjectSupport.initServletContext(javax.servlet.ServletContext) if the
given ApplicationContext is a WebApplicationContext.AbstractDetectingUrlHandlerMapping.detectHandlers() method in addition to the
superclass's initialization.SimpleUrlHandlerMapping.registerHandlers(java.util.Map<java.lang.String, java.lang.Object>) method in addition to the
superclass's initialization.WebDataBinder which
will be used for populating command and form object arguments
of annotated handler methods.@InitBinder methods) after "global" initialization
via WebBindingInitializer.WebBindingInitializer.initBinder(WebDataBinder)@InitBinder methods.@InitBinder methods.native connection sharing is enabled and
reset any previously existing connection.ContentNegotiationManager
setup and the availability of a ServletContext.HttpCookie map.ExecutorService instance.ExecutorService to its base class
but stores the actual ThreadPoolExecutor handle internally.ExtensionRegistry with Protocol Message extensionsMappedInterceptors and
adapting HandlerInterceptors and WebRequestInterceptors if necessary."methodMap", if any.@SessionAttributes.HttpServletBean, invoked after any bean properties
have been set.javax.servlet.jsp.jstl.fmt.localizationContext
context-param.WebApplicationContextUtils.initServletPropertySources(MutablePropertySources,
ServletContext, ServletConfig) that always provides null for the
ServletConfig parameter.Servlet-based stub property sources with
actual instances populated with the given servletContext and
servletConfig objects.UriComponentsBuilder from the URI template string.WebApplicationContext to be passed to the
DispatcherServlet.contextClass" and
"contextConfigLocation" context-params.TestContext as described in
prepareTestInstance().Resource-style prefix that denotes
an inline script.MapPropertySource created from inlined properties.WebSession instances.Stream of referenced inners (flatmap, multicast etc)Sources.Sources by transforming other sources.<input> tag renders an HTML 'input' tag with type 'text' using
the bound value.EmptySqlParameterSource.InstanceComparator instance.Formatter implementation for a JSR-310 Instant,
following JSR-310's parsing rules for an Instant (that is, not using a
configurable DateTimeFormatter): accepting the
default ISO_INSTANT format as well as RFC_1123_DATE_TIME
(which is commonly used for HTTP date header values), as of Spring 4.3.LoadTimeWeaver relying on VM Instrumentation.InterceptingAsyncClientHttpRequestFactory
with delegated request factory and list of interceptors.ClientHttpRequestFactory wrapper with support for ClientHttpRequestInterceptors.InterceptingClientHttpRequestFactory with the given parameters.RestTemplate
and other HTTP accessing gateway helpers, adding interceptor-related
properties to HttpAccessor's common properties.MappedInterceptor.InterceptorRegistration instance.AbstractReflectiveMBeanInfoAssembler that allows for
the management interface of a bean to be defined using arbitrary interfaces.UrlBasedViewResolver that supports
InternalResourceView (i.e.view class to InternalResourceViewResolver.requiredViewClass():
by default InternalResourceView, or JstlView if the JSTL API
is present.java.mail.internet.InternetAddress,
to directly populate an InternetAddress property.BatchPreparedStatementSetter interface,
adding a batch exhaustion check.key.keys.key and otherKey.key and otherKeys.key and otherKey.key and otherKeys.key and store result in destKey.keys and store result in destKey.otherKey and store result in destination destKey.otherKeys and store result in destination destKey.key and otherKey and store result in destKey.key and otherKeys and store result in destKey.key and otherKey and store result in destination destKey.key and otherKeys and store result in destination destKey.key and otherKey and store result in destKey.key and otherKeys and store result in destKey.key and otherKey and store result in destination destKey.key and otherKeys and store result in destination destKey.Flux that emits long values starting with 0 and incrementing at
specified time intervals on the global timer.Flux that emits long values starting with 0 and incrementing at
specified time intervals, after an initial delay, on the global timer.Task implementation defining a Runnable to be executed at a given
millisecond interval which may be treated as fixed-rate or fixed-delay depending on
context.IntervalTask.IntervalTask with no initial delay.HttpServletRequest attribute that indicates
whether type-level mappings should be inspected.JavaBeans Introspector
cache on web app shutdown.InvalidInvocationException with the supplied
error message.MediaType.parseMediaType(String) in case of
encountering an invalid media type specification String.JmxAttributeSource when it encounters
incorrect metadata on a managed resource or one of its methods.InvalidMetadataException with the supplied
error message.MimeTypeUtils.parseMimeType(String) in case of
encountering an invalid content type specification String.Comparator.reversed()HandlerMethodArgumentResolvers.HandlerMethod.InvocationFailureException with the supplied
error message.InvocationFailureException with the
specified error message and root cause.RepositoryFragment.Method by resolving theAbstractSlsbInvokerInterceptor.invokeInContext(org.aopalliance.intercept.MethodInvocation).context ClassLoader for the
managed resources ClassLoader before allowing the invocation to occur.JndiRmiClientInterceptor.doInvoke(org.aopalliance.intercept.MethodInvocation, java.lang.Object).doInvoke.afterCommit methods of the
given Spring TransactionSynchronization objects.afterCompletion methods of the
given Spring TransactionSynchronization objects.afterCompletion methods of the
given Spring TransactionSynchronization objects.HandlerMethodReturnValueHandlers.CrudRepository.deleteById(Object).Pageable as parameter if
available (i.e. the equivalent to
PagingAndSortingRepository.findAll(Pageable)), using the method taking
a Sort if available (i.e. the equivalent to
PagingAndSortingRepository.findAll(Sort) by extracting the Sort
contained in the given Pageable) or the plain equivalent to
CrudRepository.findAll().Sort as parameter if
available (i.e. the equivalent to
PagingAndSortingRepository.findAll(Sort)) or the plain equivalent to
CrudRepository.findAll().CrudRepository.findById(Object).name on the supplied
target object with the supplied value.RequestMapping handler method preparing a ModelAndView
if view resolution is required.doInvoke.Method against the supplied target
object with no arguments.Method against the supplied target
object with the supplied arguments.name on the supplied target
object with the supplied arguments.Method against the supplied target object with no arguments.Method against the supplied target object with the
supplied arguments.CrudRepository.save(Object) on the
repository.name on the supplied
target object with the supplied value.name on the supplied
target object with the supplied value.Version is the same as the given one.Matcher.HttpStatus.Series.INFORMATIONAL.HttpStatus.Series.SUCCESSFUL.HttpStatus.Series.REDIRECTION.HttpStatus.Series.CLIENT_ERROR.HttpStatus.Series.SERVER_ERROR.HttpStatus.ACCEPTED (202).HttpStatus.ACCEPTED (202).HttpStatus.ALREADY_REPORTED (208).WebContentGenerator.getCacheControl()Optionals is present.@ControllerAdvice instance.superType.isAssignableFrom(subType) is true.superType.isAssignableFrom(subType) is true.superType.isAssignableFrom(subType) is true.TypeInformation can be safely assigned to the given one.javax.servlet.DispatcherType.ASYNC introduced
in Servlet 3.0 means a filter can be invoked in more than one thread over
the course of a single request.AsyncWebRequest.startAsync().asyncSupported flag for the
DispatcherServlet and all filters added via AbstractDispatcherServletInitializer.getServletFilters().false if resource mappings were manually configured,
true otherwise.true if collections should be automatically grown.true if null references should be automatically grown.ReactiveLibrary is available.HttpStatus.BAD_GATEWAY (502).HttpStatus.BAD_REQUEST (400).HttpStatus.BAD_REQUEST (400).HttpStatus.BANDWIDTH_LIMIT_EXCEEDED (509).setValues call.Parameter is to be bound to a query.@InitBinder method should be used to initialize
the given WebDataBinder instance.Boolean.Boolean.bubbled wrapped exception.cancel signal.MonoProcessor has been interrupted via cancellation.Method is a candidate for method resolution
on an instance of the given target class.Method is a candidate for property access
on an instance of the given target class.HttpStatus.CHECKPOINT (103).Collection and Array or anything implementing Iterable.MediaType is compatible with the given media type.true if this property accessor is currently suitable for compilation.Signal.*.HttpStatus.CONFLICT (409).HttpStatus.CONTINUE (100).true if the request is a valid CORS one.true if the request is a valid CORS one.HttpStatus.CREATED (201).HttpStatus.CREATED (201).SchedulingAwareRunnable.isLongLived(),
if available.true in case of no explicit default given.PartTree is meant to be used for delete operation.false - the default), or the specifically generated values (true).true if a transaction manager
has been specified; false otherwise.HttpStatus.DESTINATION_LOCKEDdisabled' attribute.disabled' attribute.disabled' attribute.disabled' attribute.disabled' attribute.Parameter is the one used for dynamic projections.Marshaller.RepositoryComposition contains no fragments.RepositoryComposition.RepositoryFragments contains no fragments.true if the supplied Collection is null or empty.true if the supplied Map is null or empty.String is empty.Context is empty.HttpStatus.HttpStatus.Series.CLIENT_ERROR or
HttpStatus.Series.SERVER_ERROR.MonoProcessor has been completed with an error.Signal.callback not implemented
exception, in which case its cause will be the propagated
error that couldn't be processed.HttpStatus.EXPECTATION_FAILED (417).true if the session expired after maxIdleTime elapsed.FlashMap.startExpirationPeriod(int).Param.MethodParameter is explicitly annotated to be considered nullable.HttpStatus.FAILED_DEPENDENCY (424).Pageable is the fallback one.true) or
fixed delay (false) behavior.HttpStatus.FORBIDDEN (403).HttpStatus.FORBIDDEN (403).HttpStatus.FOUND (302).HttpStatus.FOUND (302).HttpStatus.GATEWAY_TIMEOUT (504).locations provided to
AbstractContextLoader.processLocations(Class, String...) are null or empty.Connection.createStruct(String, Object[])?Connection.createStruct(String, Object[])?Repository interface.DatabaseMetaData.supportsGetGeneratedKeys()?DatabaseMetaData.supportsGetGeneratedKeys()?DatabaseMetaData.supportsGetGeneratedKeys()?SmartTransactionObject interface.HttpStatus.GONE (410).Version is greater (newer) than the given one.Version is greater (newer) or the same as the given one.@SessionAttributes on the underlying controller.true if the cookie has the "HttpOnly" attribute.HttpStatus.HTTP_VERSION_NOT_SUPPORTED (505).HttpStatus.I_AM_A_TEAPOT (418).session.setAttribute
since its value cannot meaningfully change internally.HttpStatus.IM_USED (226).inheritInitializers flag that was declared via
@ContextConfiguration.inheritLocations flag that was declared via
@ContextConfiguration.Thread is forbidden
or not, by checking if the thread implements NonBlocking (in which case it is
forbidden and this method returns true).false.true.null.false.HttpStatus.INSUFFICIENT_SPACE_ON_RESOURCEHttpStatus.INSUFFICIENT_STORAGE (507).HttpStatus.INTERNAL_SERVER_ERROR (500).Serializable, Externalizable, Closeable, AutoCloseable,
Cloneable, Comparable - all of which can be ignored when looking
for 'primary' user-level interfaces.HttpStatus.LENGTH_REQUIRED (411).Version is less (older) than the given one.Version is less (older) or equal to the current one.PartTree is meant to be used for a query with limited maximal results.HttpStatus.LOCKED (423).true) versus short-lived (false).HttpStatus.LOOP_DETECTED (508).Map.Map.value.key contains value.key contains value.HttpStatus.METHOD_FAILUREHttpStatus.METHOD_NOT_ALLOWED (405).ScriptSource.getScriptAsString() was called.HttpStatus.MOVED_PERMANENTLY (301).StatusResultMatchers.isFound()Throwable to see if it is a composite, as created by Exceptions.multiple(Throwable...).HttpStatus.MULTIPLE_CHOICES (300).HttpStatus.MULTI_STATUS (207).type is a reactive wrapper type supporting multiple values (0..N
elements).Param.HttpStatus.NETWORK_AUTHENTICATION_REQUIRED (511).IsNewStrategy instances for a given class.IsNewStrategyFactory that handles Persistable implementations directly by returning a
PersistableIsNewStrategy and delegating to IsNewStrategyFactorySupport.doGetIsNewStrategy(Class) for all other types.HttpStatus.NO_CONTENT (204).HttpStatus.NO_CONTENT (204).HttpStatus.NON_AUTHORITATIVE_INFORMATION (203).Thread is forbidden
or not, by checking if the thread implements NonBlocking (in which case it is
forbidden and this method returns true).ElementType in the scope of Method requires non-null values.ElementType in the scope of type requires non-null values.ElementType in the scope of AnnotatedElement requires non-null values.HttpStatus.NOT_ACCEPTABLE (406).HttpStatus.NOT_EXTENDED (510).HttpStatus.NOT_FOUND (404).HttpStatus.NOT_FOUND (404).HttpStatus.NOT_IMPLEMENTED (501).HttpStatus.NOT_MODIFIED (304).HttpStatus.NOT_MODIFIED (304).true if the one of the checkNotModified methods
in this contract were used and they returned true.type is a reactive wrapper type that contains no value.null.null.Assert.isNull(Object, String)MethodParameter is nullable.Number.Number.Object.HttpStatus.OK (200).HttpStatus.OK (200).Transactional annotation, corresponding to the
TransactionDefinition interface.DataSource, applying the current
Spring transaction's isolation level (and potentially specified user credentials)
to every getConnection call.onComplete event.onError event.onNext event.onSubscribe event.MockHttpServletResponse.getOutputStream() access is allowed.overflow.Page of results.HttpStatus.PARTIAL_CONTENT (206).path represent a pattern that can be matched
by an implementation of this interface?HttpStatus.PAYLOAD_TOO_LARGE (413).HttpStatus.PAYMENT_REQUIRED (402).HttpStatus.PERMANENT_REDIRECT (308).HttpStatus.PERMANENT_REDIRECT (308).HttpStatus.PRECONDITION_FAILED (412).HttpStatus.PRECONDITION_REQUIRED (428).true if the request is a valid CORS pre-flight one.true if the request is a valid CORS pre-flight one.MethodInvoker.getPreparedMethod() already.true if there is a password present, otherwise false.Class identified by the supplied name is present
and can be loaded.HttpStatus.PROCESSING (102).HttpStatus.PROXY_AUTHENTICATION_REQUIRED (407).ServletContext.getResourceAsStream,
which returns null in case of a non-readable resource (e.g. a directory).readonly' attribute.CallableStatement.getObject(int) for the specified column.HttpServletResponse.encodeRedirectURL(java.lang.String) will not be applied.String.equalsIgnoreCase(String) compare the given string representation of command against the
Enum.toString() representation of the command as well as its given RedisCommand.alias.HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE (416).HttpStatus.REQUEST_ENTITY_TOO_LARGEHttpStatus.REQUEST_HEADER_FIELDS_TOO_LARGE (431).HttpStatus.REQUEST_TIMEOUT (408).HttpStatus.REQUEST_URI_TOO_LONGHttpStatus.RESET_CONTENT (205).Resolver.ResourceCallableStatement.getMoreResults/getUpdateCount.true.true.DatabaseMetaData.procedureColumnReturn or
DatabaseMetaData.procedureColumnResult.Statement.getResultSet()?@Rollback
annotation.doRollback should be performed on failure of the
doCommit call.Origin, Host,
Forwarded, X-Forwarded-Proto, X-Forwarded-Host andOrigin, Host,
Forwarded, X-Forwarded-Proto, X-Forwarded-Host andScannable.scan(Attr) resolution.true if the cookie has the "Secure" attribute.HttpStatus.SEE_OTHER (303).HttpStatus.SEE_OTHER (303).FluxProcessor supports multithread producingHttpStatus.SERVICE_UNAVAILABLE (503).true if this DeferredResult is no longer usable either
because it was previously set or because the underlying request expired.Function has the same signature as another Function.type is a reactive wrapper type for a single value.Slice.WebSession.start() or implicitly by adding session attributes.Result is a JAXP 1.4 StAX Result or
custom StAX Result.Source is a JAXP 1.4 StAX Source or
custom StAX Source.String.String.MonoProcessor has been successfully completed a value.HttpStatus.SWITCHING_PROTOCOLS (101).Filter.init and
Filter.destroy lifecycle methods on the target bean.HttpStatus.TEMPORARY_REDIRECT (307).HttpStatus.TEMPORARY_REDIRECT (307).MonoProcessor has been terminated by the
source producer with a success or an error.testClass is enabled in
the current environment, as specified by the @IfProfileValue annotation at the class level.testMethod is enabled in
the current environment, as specified by the @IfProfileValue annotation, which may be declared on the test
method itself or at the class level.testMethod is enabled in
the current environment, as specified by the @IfProfileValue annotation, which may be declared on the test
method itself or at the class level.true if @Ignore is present for the supplied
test method or if the test method is disabled
via @IfProfileValue.HttpStatus.TOO_MANY_REQUESTS (429).IllegalArgumentException
if the expression evaluates to false.IllegalArgumentException
if the expression evaluates to false.Assert.isTrue(boolean, String)HttpStatus.UNAUTHORIZED (401).HttpStatus.UNAUTHORIZED (401).HttpStatus.UNAVAILABLE_FOR_LEGAL_REASONS (451).HttpStatus.UNPROCESSABLE_ENTITY (422).HttpStatus.UNSUPPORTED_MEDIA_TYPE (415).HttpStatus.UPGRADE_REQUIRED (426).HttpStatus.REQUEST_URI_TOO_LONG (414).WebContentGenerator.getCacheControl()WebContentGenerator.getCacheControl()WebContentGenerator.getCacheControl()HttpStatus.USE_PROXYkey is valid, in particular whether the key contains a keyspace and an id part in the
form of keyspace:id.key is valid, in particular whether the key contains a keyspace and an id part in the
form of keyspace:id.type="checkbox" and type="radio" as illegal
dynamic attributes.HttpStatus.VARIANT_ALSO_NEGOTIATES (506).true if the method return type is void, false otherwise.* or the wildcard character followed by a suffix
(e.g.* or not.MockHttpServletResponse.getOutputStream() access is allowed.ObjectMapper to use.ObjectMapper based HashMapper implementation that allows flattening.Jackson2HashMapper with default ObjectMapper.Jackson2HashMapper.Decoder.Encoder.Object stream to a byte stream of JSON objects using Jackson 2.9.Jackson2JsonRedisSerializer for the given target Class.Jackson2JsonRedisSerializer for the given target JavaType.ObjectMapper instances with a fluent API.FactoryBean for creating a Jackson 2.x ObjectMapper (default) or
XmlMapper (createXmlMapper property set to true) with setters
to enable or disable Jackson features from within XML configuration.ResourceReader using Jackson to read JSON into objects.Jackson2ResourceReader.Jackson2ResourceReader using the given ObjectMapper.Object stream to a byte stream of Smile objects using Jackson 2.9.MailSender interface for JavaMail,
supporting MIME messages both as direct arguments and through preparation
callbacks.JavaMailSender interface,
supporting both JavaMail MimeMessages and Spring
SimpleMailMessages.JavaMailSenderImpl class.HttpMessageConverter that can read XML collections using JAXB2.GenericMarshaller interface for JAXB 2.2.HttpMessageConverter that can read and write XML using JAXB2.Objects (POJOs).Object stream to a byte stream containing XML elements.Input.Builder for Jaxb-Object and creating a JAXBSource.MethodInterceptor for accessing a
specific port of a JAX-WS service.FactoryBean for a specific port of a
JAX-WS service.SOAPFaultException class.LoadTimeWeaver implementation for JBoss's instrumentable ClassLoader.JBossLoadTimeWeaver class using
the default class loader.JBossLoadTimeWeaver class using
the supplied ClassLoader.SqlXmlHandler interface.JdbcTemplate and
other JDBC-accessing DAO helpers, defining common properties such as
DataSource and exception translator.NamespaceHandler for JDBC configuration namespace.JdbcTemplate that this base class manages, available to subclasses.JdbcTemplate that this base class manages, available to subclasses.JdbcTestUtils is a collection of JDBC related utility functions
intended to simplify standard database testing scenarios.Publisher.IdGenerator that calls UUID.randomUUID().JdkSerializationRedisSerializer using the default class loader.JdkSerializationRedisSerializer using a ClassLoader.JdkSerializationRedisSerializer using a converters to serialize and
deserialize objects.JedisClientConfiguration.JedisClientConfigurationBuilder implementation to build an immutable
JedisClientConfiguration.JedisClientConfiguration.JedisClientConfiguration.JedisClientConfiguration.RedisClusterConnection implementation on top of JedisCluster.JedisClusterConnection utilizing native connections via JedisCluster.JedisClusterConnection utilizing native connections via JedisCluster running commands
across the cluster via given ClusterCommandExecutor.Jedis specific ClusterCommandExecutor.ClusterCommandCallback.Jedis specific ClusterCommandExecutor.MultiKeyClusterCommandCallback.RedisConnection implementation on top of Jedis library.JedisConnection instance.JedisConnection instance backed by a jedis pool.JedisConnection instance backed by a jedis pool.JedisConnectionFactory instance with default settings (default connection pooling, no
shard information).JedisClientConfiguration and
RedisStandaloneConfiguration.JedisConnectionFactory instance using the given pool configuration.JedisConnectionFactory instance using the given JedisPoolConfig applied to
JedisSentinelPool.JedisConnectionFactory instance using the given RedisClusterConfiguration applied
to create a JedisCluster.JedisConnectionFactory instance using the given RedisStandaloneConfiguration and
JedisClientConfiguration.DataAccessExceptionsReturnTypeNamespaceHandler
for the 'jee' namespace.ServletHttpHandlerAdapter extension that uses Jetty APIs for writing
to the response with ByteBuffer.Marshaller and Unmarshaller interfaces for JiBX.MetadataMBeanInfoAssembler to
read source-level metadata from a managed resource's class.DataSourceLookup implementation.JndiLocatorSupport subclass with public lookup methods,
for convenient use as a delegate.NamingException: for example, from Spring's
JndiObjectTargetSource.FactoryBean that looks up a
JNDI object.TargetSource that provides
configurable JNDI lookups for getTarget() calls.PropertySource implementation that reads properties from an underlying Spring
JndiLocatorDelegate.JndiPropertySource with the given name
and a JndiLocatorDelegate configured to prefix any names with
"java:comp/env/".JndiPropertySource with the given name and the given
JndiLocatorDelegate.MethodInterceptor for accessing RMI services
from JNDI.FactoryBean for RMI proxies from JNDI.FactoryBean for creating a Quartz org.quartz.JobDetail
instance, supporting bean-style usage for JobDetail configuration.DateTimeFormat annotation using Joda-Time.JodaTimeContext
with user-specific Joda-Time settings.Jackson2ObjectMapperBuilder instance in order to
build a regular JSON ObjectMapper instance.Class.HttpMessageConverter
that can read and write JSON using the
JSON Binding API.JsonbHttpMessageConverter with default configuration.JsonbHttpMessageConverter with the given configuration.JsonbHttpMessageConverter with the given delegate.JsonPathExpectationsHelper.MethodInterceptorFactory to create a MethodInterceptor that willJsonProjectingMethodInterceptorFactory using the given ObjectMapper.RequestBodyAdvice implementation that adds support for Jackson's
@JsonView annotation declared on a Spring MVC @HttpEntity
or @RequestBody method parameter.ResponseBodyAdvice implementation that adds support for Jackson's
@JsonView annotation declared on a Spring MVC @RequestMapping
or @ExceptionHandler method.javax.servlet.jsp.PageContext.Converter implementations in case the we're running on Java 8.DateTimeFormat annotation using the
JSR-310 java.time package in JDK 8.javax.money.MonetaryAmount fields annotated
with Spring's common NumberFormat annotation.InternalResourceView for JSTL pages,
i.e.afterCommit /
afterCompletion callbacks of Spring TransactionSynchronization
objects callbacks after the outer JTA transaction has completed.Transactional annotation.PlatformTransactionManager implementation
for JTA, delegating to a backend JTA provider.JtaTransactionManager subclass.FactoryBean equivalent to the <tx:jta-transaction-manager/> XML element,
autodetecting WebLogic and WebSphere servers and exposing the corresponding
JtaTransactionManager subclass.UserTransaction.RedisSerializationContext using the given RedisSerializationContext.SerializationPair.RedisSerializationContext.SerializationPair adapter given RedisElementReader and RedisElementWriter.RepositoryComposition for just a single implementation with {@link MethodLookups#direct())
method lookup.RepositoryComposition.RepositoryFragments from just implementation objects.Flux that emits the provided elements and then completes.Flux that will only emit a single element then onComplete.Mono that emits the specified item, which is captured at
instantiation time.Mono that emits the specified item if Optional.isPresent() otherwise only emits
onComplete.Mono that emits the specified item if non null otherwise only emits
onComplete.ReactiveKeyCommands.ExpireAtCommand given a key.ReactiveKeyCommands.ExpireCommand given a key.ReactiveKeyCommands.MoveCommand given a key.ReactiveKeyCommands.RenameCommand given a key.ReactiveRedisConnection.RangeCommand given a key.ReactiveStringCommands.AppendCommand given a key.RedisSerializationContext.SerializationPair.RedisElementReader and RedisElementWriter.RedisSerializationContext.SerializationPair given a RedisSerializer.GroupedFlux.ScanCursorReactiveRedisConnection.KeyCommand given a key.ReactiveKeyCommands.RedisKeyCommands.MessageListener publishing RedisKeyExpiredEvents via ApplicationEventPublisher by listening
to Redis keyspace notifications for key expirations.MessageListener for __keyevent@*__:expired messages.ObjectNamingStrategy implementation that builds
ObjectName instances from the key used in the
"beans" map passed to MBeanExporter.RedisConnection.keyCommands().RedisNode.ReactiveSetCommands.SDiffCommand given a Collection of keys.ReactiveSetCommands.SDiffStoreCommand given a Collection of keys.ReactiveSetCommands.SInterCommand given a Collection of keys.ReactiveSetCommands.SInterStoreCommand given a Collection of keys.ReactiveSetCommands.SUnionCommand given a Collection of keys.ReactiveSetCommands.SUnionStoreCommand given a Collection of keys.pattern.pattern.key.key.pattern.pattern.KeyspaceConfiguration allows programmatic setup of keyspaces and time to live options for certain types.MessageListener implementation for listening to Redis keyspace notifications.KeyspaceEventMessageListener.RedisConnection.serverCommands().client.ReactiveGeoCommands.GeoDistCommand for RedisGeoCommands.DistanceUnit.KILOMETERS.<label> tag renders a form field label in an HTML 'label' tag.NamespaceHandler that supports the wiring of
objects backed by dynamic languages such as Groovy, JRuby and
BeanShell.Scannable.Attr.BUFFERED, but reserved for operators that can hold
a backlog of items that can grow beyond Integer.MAX_VALUE.ReactiveListCommands.LRemCommand to last count values.Mono, or emit
NoSuchElementException error if the source was empty.Mono, or emit
the defaultValue if the source was empty.Last-Modified header field name.null if not scheduled before.null if not scheduled before.SortedSet.last()
or otherwise iterating over all elements (assuming a linked set).Last-Modified header.RedisConnection.serverCommands().RedisConnection.serverCommands().ReactiveServerCommands.bgSave() operation in seconds.ReactiveServerCommands.bgSave() operation in seconds.RedisServerCommands.bgSave() operation in seconds.null if not scheduled before.Supplier returning the produced object for
subsequent lookups.ReactiveListCommands.BPopCommand for right push (BLPOP).ReactiveListCommands.PopCommand for right push (LPOP).ReactiveListCommands.PushCommand for left push (LPUSH).key.key .key.key.value to the bound key.values to the bound key before value.value to key.values to key before value.value to key.values to key before value.values to the bound key.values to key.values to key.values to key.values to key.values to the bound key only if the list exists.values to key only if the list exists.values to key only if the list exists.Sort instance into two expressions.LettuceClientConfiguration.LettuceClusterConnection using RedisClusterClient with default
timeout and a fresh ClusterCommandExecutor that gets destroyed on
close.LettuceClusterConnection with default timeout using
RedisClusterClient running commands across the cluster via given ClusterCommandExecutor.LettuceClusterConnection with given command timeout using RedisClusterClient
running commands across the cluster via given ClusterCommandExecutor.LettuceClusterConnection using LettuceConnectionProvider running commands across the
cluster via given ClusterCommandExecutor.LettuceClusterConnection using LettuceConnectionProvider running commands across the
cluster via given ClusterCommandExecutor.LettuceClusterConnection using LettuceConnectionProvider running commands across the
cluster via given ClusterCommandExecutor.ClusterCommandExecutor.ClusterCommandCallback.ClusterCommandExecutor.MultiKeyClusterCommandCallback.RedisConnection implementation on top of Lettuce Redis
client.LettucePoolingClientConfiguration.LettuceConnectionFactory instance with default settings.LettuceConnectionFactory instance with default settings.LettuceConnectionFactory instance with default settings.LettuceConnectionFactory instance using the given RedisSentinelConfigurationLettuceConnectionFactory instance using the given RedisClusterConfiguration
applied to create a RedisClusterClient.LettucePoolingClientConfiguration.LettuceConnectionFactory instance using the given RedisStandaloneConfiguration and
LettuceClientConfiguration.LettuceConnectionFactory instance using the given RedisSentinelConfiguration and
LettuceClientConfiguration.LettuceConnectionFactory instance using the given RedisClusterConfiguration and
LettuceClientConfiguration.LettuceConnectionProvider for providers that allow connection creation to specific nodes.DataAccessExceptionsLettucePoolingClientConfiguration.LettuceClientConfiguration.LettuceSentinelConnection with a dedicated client for a supplied RedisNode.LettuceSentinelConnection with a client for the supplied host and port and reuse
existing ClientResources.LettuceSentinelConnection using a supplied RedisClient.LettuceSentinelConnection using a supplied redis connection.LettuceSentinelConnection using a LettuceConnectionProvider.CoreSubscriber decoration.CoreSubscriber decoration.prefetchRate when propagated upstream, effectively
rate limiting the upstream Publisher.highTide first, then replenishing at the provided
lowTide, effectively rate limiting the upstream Publisher.cap.RedisZSetCommands.Limit.RedisZSetCommands.Limit.RedisConnection.listCommands()}.ReactiveListCommands.LIndexCommand.getIndex() form list at ReactiveRedisConnection.KeyCommand.getKey().index form list at key.index form list at key.Link header field name.LinkedHashMap variant that stores String keys in a case-insensitive
manner, for example for key-based access in a results table.LinkedHashMap
with the given initial capacity and stores case-insensitive keys
according to the default Locale (by default in lower case).LinkedHashMap
with the given initial capacity and stores case-insensitive keys
according to the given Locale (by default in lower case).MultiValueMap that wraps a LinkedHashMap,
storing multiple values in a LinkedList.LinkedHashMap.LinkedHashMap
with the given initial capacity.RedisConnection.listCommands()}.RedisListCommands.Position.BEFORE or RedisListCommands.Position.AFTER existing pivot for
key.value RedisListCommands.Position.BEFORE or RedisListCommands.Position.AFTER existing pivot for key.value Position#BEFORE or Position#AFTER existing pivot for key.javax.servlet.jsp.PageContext attribute under
which the bound value is exposed to inner OptionTags.ReactiveListCommands.RedisListCommands.Future with the capability to accept completion callbacks.ListenableFuture parameterized over S into a
ListenableFuture parameterized over T.ListenableFutureAdapter with the given adaptee.ListenableFuture.ListenableFuture implementations that maintains a
of success and failure callbacks and helps to notify them.FutureTask that implements ListenableFuture.ListenableFutureTask that will, upon running,
execute the given Callable.ListenableFutureTask that will, upon running,
execute the given Runnable, and arrange that FutureTask.get()
will return the given result on successful completion.CONFIG GET) from
a List to Properties.WaitStrategy.blocking() that attempts to elide conditional wake-ups when the lock is uncontended.LiveBeansView's MBean exposure.RedisConnection.listCommands()}.ReactiveRedisConnection.KeyCommand.getKey()key.key.context
from the locations or classes in the supplied MergedContextConfiguration.context
from the classes in the supplied MergedContextConfiguration.context
from the locations in the supplied MergedContextConfiguration using a
GroovyBeanDefinitionReader.context
from the locations or classes in the supplied WebMergedContextConfiguration.WebMergedContextConfiguration.context
from the locations in the supplied WebMergedContextConfiguration using a
GroovyBeanDefinitionReader.context
from the locations in the supplied WebMergedContextConfiguration, using an
XmlBeanDefinitionReader.BeanDefinition for
any classes specified by AnnotationConfigWebApplicationContext.register(Class...) and scan any packages
specified by AnnotationConfigWebApplicationContext.scan(String...).MergedContextConfiguration by delegating to the ContextLoader
configured in the given MergedContextConfiguration.context based on the supplied
locations, configures the context, and finally returns
the context in fully refreshed state.context based on the supplied
merged context configuration,
configures the context, and finally returns the context in a fully
refreshed state.SmartContextLoader to load
an ApplicationContext.AbstractDelegatingSmartContextLoader does not support the
ContextLoader.loadContext(String...) method.MergedContextConfiguration.locations.WebApplicationContext from the supplied
MergedContextConfiguration.AbstractGenericWebContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.ApplicationContext for the supplied merged context configuration.ClassFileTransformers to a ClassLoader.buildView for creating a new instance of the
specified view class, and applies the following Spring lifecycle methods
(as supported by the generic Spring bean factory):
ApplicationContextAware's setApplicationContext
InitializingBean's afterPropertiesSet
FactoryBean that creates
a local JCA connection factory in "non-managed" mode (as defined by the
Java Connector Architecture specification).JobStoreCMT class that delegates to a Spring-managed
DataSource instead of using a Quartz-managed JDBC connection pool.org.joda.time.LocalDate instances using a
org.joda.time.format.DateTimeFormatter.org.joda.time.LocalDateTime instances using a
org.joda.time.format.DateTimeFormatter.Locale to use for formatting.Locale to use for formatting.MessageInterpolator implementation but enforces Spring's
managed Locale.LocaleContextResolver to set on the
WebServerExchange.LocaleResolver, adding support for a rich locale context
(potentially including locale and time zone information).Service references.FactoryBean for locally
defined JAX-WS Service references.FactoryBean for local Stateless Session Bean (SLSB) proxies.ThreadPool adapter that delegates to a Spring-managed
Executor instance, specified on SchedulerFactoryBean.org.joda.time.LocalTime instances using a
org.joda.time.format.DateTimeFormatter.javax.validation (JSR-303) setup in a Spring
application context: It bootstraps a javax.validation.ValidationFactory and
exposes it through the Spring Validator interface
as well as through the JSR-303 Validator interface and the
ValidatorFactory interface itself.MBeanServer.MBeanServer.MBeanServer.Source object in the supplied model,
converting objects as required.ReactiveGeoCommands.GeoAddCommand given RedisGeoCommands.GeoLocation.Location header field name.Location header.Location header.ReactiveGeoCommands.GeoAddCommand given an index.MvcResult details as a DEBUG log message via
Apache Commons Logging using the log category
org.springframework.test.web.servlet.result.Logger support.Logger support.options and
trace them using Logger support.options and
trace them using Logger support.options and
trace them using a specific user-provided Logger, at Level.INFO level.Logger support.Logger support to handle trace implementation.options and use
Logger support to handle trace implementation.options and
use Logger support to
handle trace
implementation.options and
trace them using a specific user-provided Logger, at Level.INFO level.Logger support to handle trace
implementation.Logger support to handle trace
implementation.options and use
Logger support to handle trace implementation.options and use
Logger support to handle trace implementation."warnLogCategory" property.Log instance for this class.Log instance for this class.ContextCache at DEBUG level
using the "org.springframework.test.context.cache" logging category.ContextCache at DEBUG level
using the "org.springframework.test.context.cache" logging category.ObjectMapper.canDeserialize(com.fasterxml.jackson.databind.JavaType) / ObjectMapper.canSerialize(java.lang.Class<?>) check.long.RedisClusterNode matching given host and port.RedisClusterNode matching given nodeId.CacheControl instance for the given URL path.CdiRepositoryConfiguration.RedisConnection.listCommands()}.key.key.RedisConnection.listCommands()}.values to key.values to key.RedisConnection.listCommands()}.values to key only if the list exists.values to key only if the list exists.RedisConnection.listCommands()}.ReactiveRedisConnection.RangeCommand.getRange() from list at ReactiveRedisConnection.KeyCommand.getKey()start and end from list at key.start and end from list at key.RedisConnection.listCommands()}.ReactiveListCommands.LRemCommand.getCount() occurrences of ReactiveListCommands.LRemCommand.getValue() from the list stored at
ReactiveRedisConnection.KeyCommand.getKey().count occurrences of value from the list stored at key.count occurrences of value from the list stored at key.RedisConnection.listCommands()}.ReactiveListCommands.LSetCommand.getValue() list element at ReactiveRedisConnection.KeyCommand.getKey().value list element at index.value list element at index.RedisConnection.listCommands()}.ReactiveRedisConnection.KeyCommand.getKey() to elements within ReactiveRedisConnection.RangeCommand.getRange().key to elements between start and end.key to elements between start and end.ManagedAttribute attribute.ManagedNotifications.ManagedOperation attribute.ManagedOperationParameter attribute.ManagedOperationParameter attributes.ManagedResource attribute.TransactionManager reference and creating
a JTA Transaction handle for it.Streamable that will apply the given Function to the current one.Flux by applying a synchronous function
to each item.Mono by applying a synchronous function to it.DataSourceLookup implementation that relies on a map for doing lookups.MapDataSourceLookup class.MapDataSourceLookup class.MapDataSourceLookup class.Optional if both of them are present.HandlerInterceptor along with
include (and optionally exclude) path patterns to which the interceptor should apply.MappingConfiguration is used for programmatic configuration of secondary indexes, key prefixes, expirations
and the such.MappingConfiguration.HttpMessageConverter
that can read and write CBOR data format using
the dedicated Jackson 2.x extension.MappingJackson2CborHttpMessageConverter using default configuration
provided by Jackson2ObjectMapperBuilder.MappingJackson2CborHttpMessageConverter with a custom ObjectMapper
(must be configured with a CBORFactory instance).HttpMessageConverter that can read and
write JSON using Jackson 2.x's ObjectMapper.MappingJackson2HttpMessageConverter using default configuration
provided by Jackson2ObjectMapperBuilder.MappingJackson2HttpMessageConverter with a custom ObjectMapper.View that renders JSON content by serializing the model for the current request
using Jackson 2's ObjectMapper.MappingJackson2JsonView using default configuration
provided by Jackson2ObjectMapperBuilder and setting the content type
to application/json.MappingJackson2JsonView using the provided
ObjectMapper and setting the content type to application/json.HttpMessageConverter
that can read and write Smile data format ("binary JSON") using
the dedicated Jackson 2.x extension.MappingJackson2SmileHttpMessageConverter using default configuration
provided by Jackson2ObjectMapperBuilder.MappingJackson2SmileHttpMessageConverter with a custom ObjectMapper
(must be configured with a SmileFactory instance).HttpMessageConverter
that can read and write XML using
Jackson 2.x extension component for reading and writing XML encoded data.MappingJackson2XmlHttpMessageConverter using default configuration
provided by Jackson2ObjectMapperBuilder.MappingJackson2XmlHttpMessageConverter with a custom ObjectMapper
(must be a XmlMapper instance).View that renders XML content by serializing the model for the current request
using Jackson 2's XmlMapper.MappingJackson2XmlView using default configuration
provided by Jackson2ObjectMapperBuilder and setting the content type
to application/xml.MappingJackson2XmlView using the provided XmlMapper
and setting the content type to application/xml.HttpInputMessage that can eventually stores a Jackson view that will be used
to deserialize the message.MappingJackson2HttpMessageConverter along with further
serialization instructions to be passed in to the converter.MediaTypeFileExtensionResolver that maintains
lookups between file extensions and MediaTypes in both directions.createInputRecord method.extractOutputData method.RedisConverter implementation creating flat binary map structure out of a given domain type.MappingRedisConverter and defaults RedisMappingContext when null.RedisEntityInformation implementation using a RedisPersistentEntity instance to lookup the necessary
information.mapRow method for each row.SqlParameterSource implementation that holds a given Map of parameters.addValue.Map to Properties.Result.Result,
writing binary data to a MimeContainer.javax.xml.transform.Result.Node.DOMResults.MarshallingException with the specified detail message.MarshallingException with the specified detail message
and nested exception.MarshallingFailureException with the specified detail message.MarshallingFailureException with the specified detail message
and nested exception.HttpMessageConverter
that can read and write XML using Spring's Marshaller and Unmarshaller abstractions.MarshallingMessageConverter with the given Marshaller set.MarshallingMessageConverter with the given
Marshaller and Unmarshaller.Source implementation that uses a Marshaller.Can be constructed with a
Marshaller and an object to be marshalled.MarshallingSource with the given marshaller and content.View that allows for response context to be rendered as the result
of marshalling by a Marshaller.MarshallingView with no Marshaller set.MarshallingView with the given Marshaller set.OutputStream.ContentHandler.SAXResults.StaxResults.StreamResults.Writer.XMLEventWriter.XMLStreamWriter.Collection of monitored masters and their state.ScanOptions.ScanOptionsBuilder configured with the given pattern.instance is equal to the
specified candidate.instance matches one of the candidates.path against the given pattern,
according to this PathMatcher's matching strategy.HandlerMapping can implement to expose
a request matching API aligned with its internal request matching
configuration and implementation.HttpMethod matches the given
method value.AbstractRequestExpectationManager.validateRequestInternal(ClientHttpRequest) in order to match the
request to an expectation, leaving the call to create the response as a separate step
(to be invoked by this class).path against the corresponding part of the given
pattern, according to this PathMatcher's matching strategy.Signal instances,
materializing these signals.Signal instances,
materializing these signals.HttpServletRequest attribute that contains a map with
URI variable names and a corresponding MultiValueMap of URI matrix
variables for each.Map annotated with @MatrixVariable
where the annotation does not specify a name.@MatrixVariable.max number of times.ContextCache
as a positive integer.Max-Forwards header field name.Matcher.MethodInterceptor that routes calls to an
MBean running on the supplied MBeanServerConnection.MBeanConnectFailureException
with the specified error message and root cause.MBeanServer, without the need to define any
JMX-specific information in the bean classes.MBeanExporter.MBeanExportException with the
specified error message.MBeanExportException with the
specified error message and root cause.MBeanInfoRetrievalException with the
specified error message.MBeanInfoRetrievalException with the
specified error message and root cause.MBeanExporter after an MBean has been successfully
registered with an MBeanServer.MBeanServer.FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector.FactoryBean that obtains an MBeanServer reference
through the standard JMX 1.2 MBeanServerFactory
API (which is available on JDK 1.5 or as part of a JMX 1.2 provider).MBeanServer,
or when more than one instance is found.MBeanServerNotFoundException with the
supplied error message.MBeanServerNotFoundException with the
specified error message and root cause.MBeanExporter after an MBean has been successfully
unregistered from an MBeanServer.MediaType.ALL that is returned from
ContentNegotiationStrategy.resolveMediaTypes(org.springframework.web.context.request.NativeWebRequest) when no specific media types are requested.MimeType that adds support for quality parameters
as defined in the HTTP specification.MediaType for the given primary type.MediaType for the given primary type and subtype.MediaType for the given type, subtype, and character set.MediaType for the given type, subtype, and quality value.MediaType, and allows to set the specified character set.MediaType,
and allows for different parameter.MediaType for the given type, subtype, and parameters.MediaType objects
from Resource handles or filenames.MediaType to a list of file extensions.ReactiveGeoCommands.GeoHashCommand given a member.ReactiveGeoCommands.GeoPosCommand given a member.ReactiveGeoCommands.GeoHashCommand given a Collection of values.ReactiveGeoCommands.GeoPosCommand given a Collection of values.ReactiveSetCommands.SPopCommand for count members.key.key.Publisher sequences emitted by the passed Publisher
into an interleaved merged sequence.Publisher sequences emitted by the passed Publisher
into an interleaved merged sequence.Publisher sequences emitted by the passed Publisher
into an interleaved merged sequence.Publisher sequences contained in an Iterable
into an interleaved merged sequence.Publisher sequences contained in an array / vararg
into an interleaved merged sequence.Publisher sequences contained in an array / vararg
into an interleaved merged sequence.byte arrays into one arrayMap into this Map,
with existing objects of the same name taking precedence (i.e. not getting
replaced).Map into this Map,
with existing objects of the same name taking precedence (i.e. not getting
replaced).Map into this Map,
with existing objects of the same name taking precedence (i.e. not getting
replaced).Map with existing objects of
the same name taking precedence (i.e. not getting replaced).Map into this Map,
with existing objects of the same name taking precedence (i.e. not getting
replaced).MergedContextConfiguration encapsulates the merged
context configuration declared on a test class and all of its superclasses
via @ContextConfiguration,
@ActiveProfiles, and
@TestPropertySource.MergedContextConfiguration instance for the
supplied parameters.MergedContextConfiguration instance for the
supplied parameters.MergedContextConfiguration instance for the
supplied parameters.MergedContextConfiguration instance by copying
all fields from the supplied MergedContextConfiguration.MergedContextConfiguration instance for the
supplied parameters.MergedContextConfiguration instance for the
supplied parameters.Publisher sequences contained in an array / vararg
into an interleaved merged sequence.Publisher sequences into an ordered merged sequence,
by picking the smallest values from each source (as defined by their natural order).Publisher sequences into an ordered merged sequence,
by picking the smallest values from each source (as defined by the provided
Comparator).Publisher sequences into an ordered merged sequence,
by picking the smallest values from each source (as defined by the provided
Comparator).Flux and a Publisher into a reordered merge
sequence, by picking the smallest value from each sequence as defined by a provided
Comparator.HttpClient-level RequestConfig with
the factory-level RequestConfig, if necessary.Publisher sequences emitted by the passed Publisher
into an ordered merged sequence.Publisher sequences emitted by the passed Publisher
into an ordered merged sequence.Publisher sequences provided in an array/vararg
into an ordered merged sequence.Publisher sequences provided in an array/vararg
into an ordered merged sequence.Publisher sequences provided in an Iterable
into an ordered merged sequence.Publisher sequences provided in an Iterable
into an ordered merged sequence.Publisher sequences emitted by the passed Publisher
into an ordered merged sequence.Publisher sequences provided in an array/vararg
into an ordered merged sequence.Publisher sequences provided in an Iterable
into an ordered merged sequence.LinkedHashSet
(with every entry included at most once, even entries within the first array)Flux and a Publisher into an interleaved merged
sequence.Mono with the provided Publisher.MessageListenerAdapter with default settings.MessageListenerAdapter for the given delegate.MessageListenerAdapter for the given delegate.page context scope.ResourceBundleLocator interface,
exposing a Spring MessageSource as localized MessageSourceResourceBundle.<message> tag looks up a message in the scope of this page.MetaAnnotationUtils is a collection of utility methods that complements
the standard support already available in AnnotationUtils.Annotation, including the class on which the annotation is declared
as well as the actual annotation instance.AnnotationDescriptor that is used
to describe the declaration of one of several candidate annotation types
where the actual annotation type cannot be predetermined.MBeanInfoAssembler interface that reads
the management interface information from source level metadata.MetadataMBeanInfoAssembler which needs to be
configured through the MetadataMBeanInfoAssembler.setAttributeSource(org.springframework.jmx.export.metadata.JmxAttributeSource) method.MetadataMBeanInfoAssembler for the given
JmxAttributeSource.ObjectNamingStrategy interface
that reads the ObjectName from the source-level metadata.MetadataNamingStrategy which needs to be
configured through the MetadataNamingStrategy.setAttributeSource(org.springframework.jmx.export.metadata.JmxAttributeSource) method.MetadataNamingStrategy for the given
JmxAttributeSource.ReactiveGeoCommands.GeoDistCommand for RedisGeoCommands.DistanceUnit.METERS.URI.MockServerHttpRequest.method(HttpMethod, URI) that accepts a URI template.HttpMethod of the request.HttpMethod.@Valid fails.MethodArgumentNotValidException.AbstractReflectiveMBeanInfoAssembler subclass that allows
method names to be explicitly excluded as MBean operations and attributes.FactoryBean that exposes a
org.quartz.JobDetail object which delegates job execution to a
specified (static or non-static) method.Runnable interface as a configurable
method invocation based on Spring's MethodInvoker.predicates to resolve a method called on a composite to its
implementation method.Method.MethodLookup.InvokedMethod and method candidate.TransactionAttributeSource implementation that
allows attributes to be stored per method in a Map.Matcher.AbstractReflectiveMBeanInfoAssembler that allows
to specify method names to be exposed as MBean operations and attributes.MethodProperty is a Property which is accessed
through accessor methods (setX, getX).MetadataReader for accessing class metadata and method metadata as read by an ASM
ClassReader.SimpleMetadataReaderFactory that reads MethodsMetadata, creating a new ASM
MethodsMetadataReader for every request.MethodsMetadataReaderFactory for the default class loader.MethodsMetadataReaderFactory for the given ResourceLoader.MethodsMetadataReaderFactory for the given ClassLoader.MethodInterceptor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods.BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods.ManagedMetric will change over time.RedisConnection.stringCommands()}.keys.keys.RedisConnection.serverCommands().RedisConnection.serverCommands().ReactiveGeoCommands.GeoDistCommand for RedisGeoCommands.DistanceUnit.MILES.DateTimeFormatter.Expiration with TimeUnit.MILLISECONDS.milliseconds to the given TimeUnit.Converter to convert from milliseconds to the given TimeUnit.Marshaller that can use MIME attachments to optimize
storage of binary data.javax.mail.internet.MimeMessage.MimeType for the given primary type.MimeType for the given primary type and subtype.MimeType for the given type, subtype, and character set.MimeType,
and allows to set the specified character set.MimeType,
and allows for different parameter.MimeType for the given type, subtype, and parameters.MimeType utility methods.Unmarshaller that can use MIME attachments
to optimize storage of binary data.min number of times.ServletRequestBindingException subclass that indicates that a path
variable expected in the method parameters of an @RequestMapping
method is not present among the URI variables extracted from the URL.PropertyUtils.setSkipMissingProperties(boolean) is set to true.ServletRequestBindingException subclass that indicates a missing parameter.MockPropertySource instances not
otherwise given an explicit name.AsyncContext interface.javax.servlet.jsp.tagext.BodyContent class.ClientHttpRequest.ClientHttpRequest.ClientHttpResponse.ClientHttpResponse.ConfigurableEnvironment implementation exposing
MockEnvironment.setProperty(String, String) and MockEnvironment.withProperty(String, String)
methods for testing purposes.MockEnvironment with a single MockPropertySource.javax.servlet.jsp.el.ExpressionEvaluator
interface, delegating to the Apache JSTL ExpressionEvaluatorManager.FilterChain interface.Filter implementation.FilterChain with Filter's and a Servlet.FilterConfig interface.MockServletContext.MockServletContext.HttpInputMessage.HttpOutputMessage.HttpServletRequest interface.MockHttpServletRequest with a default
MockServletContext.MockHttpServletRequest with a default
MockServletContext.MockHttpServletRequest with the supplied ServletContext.MockHttpServletRequest with the supplied ServletContext,
method, and requestURI.MockHttpServletRequest required as input to
perform requests in MockMvc.HttpServletResponse interface.HttpSession interface.MockServletContext.javax.servlet.jsp.JspWriter class.MultipartFile
interface.MultipartHttpServletRequest interface.MockMultipartHttpServletRequest with a default
MockServletContext.MockMultipartHttpServletRequest with the supplied ServletContext.MockMultipartHttpServletRequest.MockMvc instance.MockMvcBuilders.MockMvc instance.ClientHttpRequestFactory for requests executed via MockMvc.ConfigurableMockMvcBuilder in some
specific way, e.g. a 3rd party library that wants to provide shortcuts for
setting up a MockMvc.MockMvcConfigurer.MockMvcHtmlUnitDriverBuilder simplifies the building of an
HtmlUnitDriver that delegates to MockMvc and optionally
delegates to an actual connection for specific requests.RequestBuilders.ResultHandler-based result actions.ResultMatcher-based result actions.MockMvcWebClientBuilder based on the supplied
MockMvc instance.MockMvcHtmlUnitDriverBuilder based on the supplied
MockMvc instance.MockMvcWebClientBuilder simplifies the creation of an HtmlUnit
WebClient that delegates to a MockMvc instance."" (i.e., the root context).WebConnection that
uses MockMvc and optionally delegates to a real WebConnection
for specific requests.MockMvc instance.WebApplicationContext.WebApplicationContext
and MockMvcConfigurer.javax.servlet.jsp.PageContext interface.MockServletContext,
MockHttpServletRequest, MockHttpServletResponse,
MockServletConfig.MockHttpServletRequest,
MockHttpServletResponse, MockServletConfig.javax.servlet.http.Part.PropertySource implementation for use in testing.MockPropertySource named "mockProperties"
that will maintain its own internal Properties instance.MockPropertySource with the given name that will
maintain its own internal Properties instance.MockPropertySource with the given name and backed by the given
Properties object.RequestDispatcher interface.RequestMatcher classes.ResponseCreator instance.MockRestServiceServer.WebTestClient.MockServerSpec and expose that
as a shortcut.AbstractServerHttpRequest for use in tests without
an actual server.AbstractServerHttpResponse for use in tests without
an actual server.ServerRequest.MockServerRequest.DefaultServerWebExchange for use in tests with
MockServerHttpRequest and MockServerHttpResponse.ServletConfig interface.MockServletContext.MockServletContext.ServletContext interface.MockServletContext, using no base path and a
DefaultResourceLoader (i.e. the classpath root as WAR root).MockServletContext, using a DefaultResourceLoader.MockServletContext, using the specified ResourceLoader
and no base path.MockServletContext using the supplied resource base
path and resource loader.SessionCookieConfig interface.@ModelAttribute methods.javax.servlet.jsp.PageContext attribute under which the
form object name is exposed.ModelAndView objects.HandlerMethodArgumentResolvers and
HandlerMethodReturnValueHandlers during the course of invocation of
a controller method.ModelAndView copying view and model
information to the ModelAndViewContainer.true for
all return types).@ModelAttribute annotated method arguments and handle
return values from @ModelAttribute annotated methods.Model before controller method
invocation and with updates to it after the invocation.@ModelAttribute methods.Map for use when building model data for use
with UI tools.ModelMap.ModelMap containing the supplied attribute
under the supplied name.ModelMap containing the supplied attribute.NotificationPublisher implementation that uses the infrastructure
provided by the ModelMBean interface to track
javax.management.NotificationListeners
and send Notifications to those listeners.ModelMBeanNotificationPublisher class
that will publish all Notifications
to the supplied ModelMBean.RequestPath instance with a modified context path.AnnotationConfigContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.AnnotationConfigWebContextLoader should be used as a
SmartContextLoader,
not as a legacy ContextLoader.WebClient and retain a reference to it so that its
WebConnection is accessible for later use.WebClient.ObjectMapper.ObjectMapper.ObjectMapper.ObjectMapper.javax.money.MonetaryAmount values,
delegating to javax.money.format.MonetaryAmountFormat#format
and javax.money.format.MonetaryAmountFormat#parse.RedisNode.getName(),
RedisNode.getHost(), RedisNode.getPort(), and RedisServer.getQuorum().Publisher with basic rx operators that completes successfully by emitting an element, or
with an error.MonoOperator wrapper around the passed parent PublisherMonoProcessor is a Mono extension that implements stateful semantics.RedisConnection.keyCommands().key to database with index.key to database with index.key to database with index.value from the bound key to destKeykey to database with index.value from key to destKeykey to database with index.value from key to destKeyIterable.RedisConnection.stringCommands()}.ReactiveStringCommands.MSetCommand given a Map of key-value tuples.tuple.RedisConnection.stringCommands()}.tuple only if the provided key does
not exist.tuple only if the provided key does
not exist.tuple.keys from the hash at the bound key.hashKeys from hash at key.hashKeys from hash at key.keys.keys.ElementSelector that allows two elements to be compared if
their name (including namespace URI, if any) and textual content is
the same at a certain level of nesting.levels child
elements deeper into the element to compare elements.levels child
elements deeper into the element to compare elements.MockMultipartHttpServletRequestBuilder for a multipart request.MockMultipartHttpServletRequestBuilder for a multipart request.multipart/form-data.MediaType.MULTIPART_FORM_DATA.MultipartBodyBuilder.HttpEntity for use with a
Publisher-based body, for which we also need to keep track of
the element type.MultipartHttpMessageWriter.MultipartResolver.HttpMessageReader for reading "multipart/form-data" requests
into a MultiValueMap<String, Part>.HttpMessageWriter for writing a {@code MultiValueMapHandlerMethodArgumentResolver implementations
which need to resolve MultipartFile and Part arguments.Throwable(s),
as suppressed exceptions.Throwable(s),
as suppressed exceptions.tuple.tuple.tuple only if the provided key does
not exist.tuple only if the provided key does
not exist.Map interface that stores multiple values.ServerHttpRequestDecorator and returning either mutated
values or delegating back to this instance.ServerWebExchangeDecorator and returning either mutated
values or delegating back to this instance.WebTestClient, apply the given configurer, and build
a new instance.CompositeUriComponentsContributor object in the bean factory.ContentNegotiationManager instance to use to determine
requested media types in a given request.FormattingConversionService for use with annotated
controller methods and the spring:eval JSP tag.NamespaceHandler for Spring MVC configuration namespace.PathMatcher instance for path matching
patterns in HandlerMappings.ResourceUrlProvider bean for use with the MVC dispatcher.UriComponentsBuilder
by pointing to @RequestMapping methods on Spring MVC controllers.CompositeUriComponentsContributor for use with
MvcUriComponentsBuilder.UrlPathHelper instance for path matching
patterns in HandlerMappings.Validator instance for example for validating
@ModelAttribute and @RequestBody method arguments.ViewResolverComposite that contains a chain of view resolvers
to use for view resolution.DataFieldMaxValueIncrementer that increments the maximum value of a given MySQL table
with the equivalent of an auto-increment column.Matcher.Scannable.name()
as long as this is the first reachable Scannable.parents().Scannable.name()
as long as this is the first reachable Scannable.parents().Scannable.name()
as long as this is the first reachable Scannable.parents().Scannablee and its Scannable.parents() for a name an return the
first one that is reachable.DataSource.JdbcTemplate.NamedQueries that can be looked up by their names.BeanDefinition for a NamedQueries instance.NamedQueriesBeanDefinitionBuilder using the given default location.BeanDefinitionParser to create BeanDefinitions of NamedQueries instances looking up a
Properties file fom the given location.NamedQueriesBeanDefinitionParser using the given default location.TransactionAttributeSource implementation that
allows attributes to be matched by registered name.WebRequest interface, exposing the
native request and response objects in a generic fashion.<nestedPath> tag supports and assists with nested beans or
bean properties in the model.ServletException that properly handles a root cause in terms
of message and stacktrace, just like NestedChecked/RuntimeException does.NestedServletException with the specified detail message.NestedServletException with the specified detail message
and nested exception.ReactorClientHttpConnectorNetty4ClientHttpRequestFactory with a default
NioEventLoopGroup.Netty4ClientHttpRequestFactory with the given
EventLoopGroup.Disposable that can never be disposed.Flux that will never signal any data, error or completion signal.Mono that will never signal any data, error or completion signal,
essentially running indefinitely.String map.createSqlRowSet implementation.Scheduler that dynamically creates Workers resources and caches
eventually, reusing them once the Workers have been shut down.Scheduler that dynamically creates ExecutorService-based Workers and caches
the thread pools, reusing them once the Workers have been shut down.Scheduler that dynamically creates ExecutorService-based Workers and caches
the thread pools, reusing them once the Workers have been shut down.Scheduler that dynamically creates ExecutorService-based Workers and caches
the thread pools, reusing them once the Workers have been shut down.Scheduler that dynamically creates ExecutorService-based Workers and caches
the thread pools, reusing them once the Workers have been shut down.org.apache.commons.fileupload.servlet.ServletFileUpload
instance.RedisGeoCommands.GeoRadiusCommandArgs.BeanPropertyRowMapper
(with the mapped class specified only once).SingleColumnRowMapper
(with the required type specified only once).SingleColumnRowMapper
(with the required type specified only once).SqlXmlValue implementation to be used together
with the database specific implementation of this SqlXmlObjectMappingHandler.Scheduler that hosts a fixed pool of workers and is suited for parallel
work.Scheduler that hosts a fixed pool of single-threaded ExecutorService-based
workers and is suited for parallel work.Scheduler that hosts a fixed pool of single-threaded ExecutorService-based
workers and is suited for parallel work.Scheduler that hosts a fixed pool of single-threaded ExecutorService-based
workers and is suited for parallel work.Scheduler that hosts a fixed pool of single-threaded ExecutorService-based
workers and is suited for parallel work.PartialUpdate for given id and type.RedisClusterNode.RedisClusterNodeBuilder for creating new RedisClusterNode.RedisNode.RedisNodeBuilder for creating new RedisNode.List.RedisSerializationContext.RedisSerializationContextBuilder.RedisSerializationContext.RedisSerializationContextBuilder using a given default RedisSerializer.RedisSerializationContext.RedisSerializationContextBuilder using a given default RedisSerializationContext.SerializationPair.RedisServer from the given properties.Scheduler that hosts a single worker and is suited for non-blocking
work.Scheduler that hosts a single-threaded ExecutorService-based worker and is
suited for parallel work.Scheduler that hosts a single-threaded ExecutorService-based worker and is
suited for parallel work.Scheduler that hosts a single-threaded ExecutorService-based worker and is
suited for parallel work.SqlXmlValue instance for the given XML data,
as supported by the underlying JDBC driver.SqlXmlValue instance for the given XML data,
as supported by the underlying JDBC driver.SqlXmlValue instance for the given XML data,
as supported by the underlying JDBC driver.SqlXmlValue instance for the given XML data,
as supported by the underlying JDBC driver.SqlXmlValue instance for the given XML data,
as supported by the underlying JDBC driver.Iterator or Optional.empty() in case there is no next
element.Date in the sequence matching the Cron pattern and
after the value provided.Signal of variety Type.NEXT, which holds
the value.Signal of variety Type.NEXT, which holds
the value and the Context associated with the emitting source.BackOffExecution.STOP (-1L) to indicate that no further attempt
should be made for the operation.true if the next child is one of the specified classes.CharSequence,
returning the index of the next character that requires escaping.Thread.Node and apply the given Matcher.Matcher<Node>.Node and apply the given Hamcrest
Matcher.Node content found with the
given Hamcrest Matcher.Matcher<Integer>.Matcher.Node class that represent node types.Threads while executing Reactor
blocking APIs, resulting in these calls throwing an exception.InputStream where calling
close() has no effect.OutputStream where calling
close() has no effect.RedisPassword.null.null.null elements.null elements.Assert.noNullElements(Object[], String)Runnable that can be used as a placeholder spin observer with
WaitStrategy.waitFor(long, LongSupplier, Runnable)RollbackRuleAttribute that has the opposite behavior
to the RollbackRuleAttribute superclass.NoRollbackRuleAttribute class
for the supplied Throwable class.NoRollbackRuleAttribute class
for the supplied exceptionName.null and must contain at least one element.null and must contain at least one element.Assert.notEmpty(Object[], String)null and must contain at least one element.null and must contain at least one element.Assert.notEmpty(Collection, String)null
and must contain at least one entry.null
and must contain at least one entry.Assert.notEmpty(Map, String)NotificationListener,
a NotificationFilter, and an arbitrary handback object.NotificationListenerBean class.NotificationListenerBean class.NotificationListener,
a NotificationFilter, and an arbitrary handback
object, as well as the names of MBeans from which the listener wishes
to receive Notifications.NotificationListener
with one or more MBeans in an MBeanServer
(typically via a MBeanServerConnection).MBeanServer.MBeanServer and wishes to send
JMX javax.management.Notifications.null.null.Assert.notNull(Object, String)null under
some circumstance.null under some circumstance.NullableWrapper for the given value.String representation of the supplied
ContextLoader based solely on the fully qualified name of the
loader or "null" if the supplied loader is null.null based on the
provided flag, decorating the given Comparator.true if
both are null or false if only one is null.Object#hashCode()}.Comparable adapter which accepts
null values and sorts them higher than non-null values.Comparable adapter which accepts
null values and sorts them lower than non-null values.Double value found with the
given Hamcrest Matcher.Double value found.NumberFormat annotation.HashMapper based on MappingRedisConverter.ObjectHashMapper.ObjectHashMapper.ObjectName instances.ObjectName instances.HttpMessageConverter that uses StringHttpMessageConverter
for reading and writing content and a ConversionService for converting
the String content to and from the target object type.ConversionService to use to convert the
(String) message body to/from the target class type.ConversionService as well as a default charset.ConnectionFactory for actual use (never null).DataSource for actual use (never null).RedisPassword from a String.RedisPassword from a char array.key into MappingRedisConverter.BinaryKeyspaceIdentifier.key into MappingRedisConverter.KeyspaceIdentifier.RedisScript from String.RedisScript from String.RepositoryComposition from fragments with
{@link MethodLookups#direct()) method lookup.RepositoryComposition from fragments with
{@link MethodLookups#direct()) method lookup.RepositoryComposition from RepositoryComposition.RepositoryFragments and RepositoryMetadata with
{@link MethodLookups#direct()) method lookup.RepositoryComposition.RepositoryFragments from fragments.Lazy to produce an object lazily.Pair for the given elements.Streamable with the given elements.Streamable for the given Iterable.Context pre-initialized with one key-value pair.Context pre-initialized with two key-value pairs.Context pre-initialized with three key-value pairs.Context pre-initialized with four key-value pairs.Context pre-initialized with five key-value pairs.Tuple2 with the given objects.Tuple3 with the given objects.Tuple4 with the given objects.Tuple5 with the given objects.Tuple6 with the given objects.Tuple7 with the given objects.Tuple8 with the given objects.Class type.Class type.ResponseEntity with the given body and
the status set to OK.ClientHttpRequestFactory implementation that uses
OkHttp 3.x to create requests.OkHttpClient instance.OkHttpClient instance.Hooks pointcut given a
ConnectableFlux, potentially returning a new ConnectableFlux.Flux, or park the
observed elements if not enough demand is requested downstream.Flux, or park the
observed elements if not enough demand is requested downstream.Flux, or park the
observed elements if not enough demand is requested downstream.Flux, or park the observed
elements if not enough demand is requested downstream, within a maxSize
limit.Flux, or park the observed
elements if not enough demand is requested downstream, within a maxSize
limit.Flux, or park the observed
elements if not enough demand is requested downstream, within a maxSize
limit and for a maximum Duration of ttl (as measured on the
elastic Scheduler).Flux, or drop
the observed elements if not enough demand is requested downstream.Flux, or emit onError
fom Exceptions.failWithOverflow() if not enough demand is requested
downstream.Flux, or only keep
the most recent observed item if not enough demand is requested downstream.onblur' attribute.Subscription.cancel().onchange' attribute.RepositoryQuery was created.AbstractListenerReadPublisher.checkOnDataAvailable(), or as a callback from the underlying
container.ReactiveSetCommands.SPopCommand for a single member.Flux by synchronously applying a function to it.Flux by synchronously applying a function
to it if the error matches the given type.Flux by synchronously applying a function
to it if the error matches the given predicate.Mono by synchronously applying a function
to it if the error matches the given predicate.Mono by synchronously applying a function to it.Mono by synchronously applying a function
to it if the error matches the given type.Flux.Flux.Flux.Mono.Mono.Mono.ListenableFuture completes with failure.AbstractListenerWriteFlushProcessor.isWritePossible(), or as a callback from the underlying
container.onfocus' attribute.Scheduler has
handled an error.MessageListener entry point.onNextDropped hook(s) and
apply a strategy of throwing Exceptions.failWithCancel() instead.Subscription.Subscription.DispatcherServlet.initStrategies(org.springframework.context.ApplicationContext).ObjectName.ObjectName.RejectedExecutionException which can be thrown by the
operator.RejectedExecutionException which can be thrown by the
operator.LongConsumer to this FluxSink that will be notified of
any request to this sink.LongConsumer to this MonoSink that will be notified of
any request to this sink.ServletContext to any WebApplicationInitializer
implementations present on the application classpath.ServletContext with any servlets, filters, listeners
context-params and attributes necessary for initializing this web application.Subscriber.onNext(Object) before
calling Subscription.request(long).ListenableFuture completes with success.Subscriber and the Subscription on
termination or cancellation.Subscriber and the Subscription on
termination or cancellation.ObjectName.AbstractListenerWriteProcessor.isWritePossible(), or as a callback from the underlying
container.AbstractHtmlElementBodyTag.writeTagContent(org.springframework.web.servlet.tags.form.TagWriter) allowing subclasses to perform
any precondition checks or setup tasks that might be necessary.select' tag before proceeding.Cursor prior to usage.HttpURLConnection for the given remote invocation request.OperatorOverloader can implement for any pair of
operands.instanceof does in Java.Scannablee and its Scannable.parents() for a name an return the
first one that is reachable.Operation support simple types
like numbers.Subscription.request(long) handling.multiply operator.RedisSerializationContext.RedisSerializationContext.RedisSerializationContext.RedisSerializationContext.RedisSerializationContext.RedisSerializationContext.Optionals.LocalValidatorFactoryBean subclass that simply turns
Validator calls into no-ops
in case of no Bean Validation provider being available.MockHttpServletRequestBuilder for an OPTIONS request.MockHttpServletRequestBuilder for an OPTIONS request.<options> tag renders a list of HTML 'option' tags.<option> tag renders a single HTML 'option'.Publisher between this Flux and another publisher
to emit any signal (onNext/onError/onComplete) and replay all signals from that
Publisher, effectively behaving like the fastest of these competing sources.CallMetaDataProvider interface.DataFieldMaxValueIncrementer that retrieves the next value
of a given Oracle sequence.TableMetaDataProvider.ViewResolverComposite and follow the order of registration.Comparator, picking the smallest of all rails.Comparator, picking the smallest of all rails.Supplier in case the original
value is null.java.util.atomic package in Redis.java.util collections on top of Redis.java.util.Date properties.java.time package in JDK 8.java.lang.Number properties.javax.money package.ClientHttpRequest and
ClientHttpResponse as well as a
ClientHttpConnector.Encoder
and Decoder for web use.ClientCodecConfigurer
and ServerCodecConfigurer based on the converter
implementations from org.springframework.http.codec.json and co.ServerHttpRequest and
ServerHttpResponse along with an
HttpHandler for processing.org.springframework.jca.cci.core package.org.springframework.jdbc.core package.MBeanServers
and for exposing an MBeanServer to remote clients.Environment and
PropertySource
abstractions introduced in Spring 3.1.java.util.concurrent
and javax.enterprise.concurrent packages, allowing to set up a
ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring
context.@Sql.Rules used in the Spring TestContext Framework.Statements used in the Spring TestContext Framework.RequestMatcher
implementations.ResponseCreator
implementations.WebTestClient.MockMvc
and HtmlUnit.MockMvc
and the Selenium HtmlUnitDriver.RequestBuilder
implementations.ResultMatcher and ResultHandler implementations.MockMvcBuilder implementations.java.util.Comparator implementations,
such as an invertible comparator and a compound comparator.java.util.concurrent.Future extension.org.springframework.web.client package.org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes.CorsProcessor strategy.CorsProcessor strategy.WebFilter implementations for use in
reactive web applications.org.springframework.web.servlet.mvc.method package.org.springframework.http.client.reactive reactive HTTP adapter
and HttpHandler.WebHandlerDecorator.WebSession support.org.springframework.web.method package.org.springframework.web.method.annotation package.DifferenceEngine that is
at the heart of all comparisons as well as supporting interfaces
and implementations.Source implementations.Origin header field name.FlashMap with
attributes to save for a subsequent request.ReactiveStringCommands.SetRangeCommand given a key.NamespaceHandler for the 'oxm' namespace.OxmSerializer.Pageable object from a NativeWebRequest for a particular
MethodParameter.Pageable into a controller
method.Pageable.Pageable instances into controller
methods.SortHandlerMethodArgumentResolver.SortHandlerMethodArgumentResolver.SortArgumentResolver.PageableHandlerMethodArgumentResolver configuration.ResourceAssembler to easily convert Page instances into PagedResources.PagedResourcesAssembler using the given PageableHandlerMethodArgumentResolver and
base URI.HandlerMethodArgumentResolver to allow injection of PagedResourcesAssembler into Spring MVC
controller methods.PagedResourcesAssemblerArgumentResolver using the given
PageableHandlerMethodArgumentResolver and MethodLinkBuilderFactory.CrudRepository to provide additional methods to retrieve entities using the pagination and
sorting abstraction.Flux by dividing data on a number of 'rails' matching the
number of CPU cores, in a round-robin fashion.Flux by dividing data on a number of 'rails' matching the
provided parallelism parameter, in a round-robin fashion.Scheduler that hosts a fixed pool of single-threaded ExecutorService-based
workers and is suited for parallel work.'groups').MockHttpServletRequest.ParamTag to a
ParamAware tag.spring:param tags.Parameter for the given MethodParameter.SqlLobValue objects.MBeanParameterInfo into an array of
Class instances corresponding to the parameters.MBeanParameterInfo into an array of
Class instances corresponding to the parameters.JdbcTemplate class for
batch updates.ContentNegotiationConfigurer.favorParameter(boolean) is on.Parameter with an invalid index inside a Parameters
instance.ParameterOutOfBoundsException with the given exception as cause.Parameters.Parameters instance with the given Parameters put into new context.ParameterAccessor implementation using a Parameters instance to find special parameters.ParametersParameterAccessor.MockHttpServletRequest,
for example when testing a form submission.RequestMapping.params().<param> tag collects name-value parameters and passes them to a
ParamAware ancestor in the tag hierarchy.Stream navigating the Subscription
chain (upward).TypeInformation implementations that need parent type awareness.ParentTypeAwareTypeInformation.LockSupport.parkNanos(1)) for the minimum number of nanos the OS and JVM will allow while the
consumers are waiting on a barrier.LockSupport.parkNanos(1)) for the minimum number of nanos the
OS and JVM will allow while the consumers are waiting on a barrier.Version object.RequestPath with the given parameters.String value into a Locale, accepting
the Locale.toString() format as well as BCP 47 language tags.String representation into a Locale.MediaType.MediaType objects.MediaType objects.MimeType.MimeType objects.text into a Number instance of the given
target class, using the corresponding decode / valueOf method.text into a Number instance of the
given target class, using the supplied NumberFormat.Separator and
PathSegment elements.Events.HttpRange objects.Parser implementations in case of malformed
input.timeZoneString value into a TimeZone.Version.Document.String parsing.MultipartBodyBuilder.part(String, Object) that also accepts a MediaType
which is used to determine how to encode the part.Part components to the request.PartialUpdate allows to issue individual property updates without the need of rewriting the whole entity.PartialUpdate for given id and type.PartialUpdate for given id and object.String into a tree or PartTree.OrParts consisting of simple Part instances in turn.PassThroughExceptionTranslationStrategy returns null for unknown Exceptions.FilterConfig interface which
simply passes the call through to a given Filter/FilterChain combination
(indicating the next Filter in the chain along with the FilterChain that it is
supposed to work on) or to a given Servlet (indicating the end of the chain).<password> tag renders an HTML 'input' tag with type 'password'
using the bound value.MockHttpServletRequestBuilder for a PATCH request.MockHttpServletRequestBuilder for a PATCH request.PATCH requests onto specific handler
methods."rawPath" of the URI of
the request with the following conditions:
If uri is also set, the path given here
overrides the path of the given URI.Matcher.HttpServletRequest attribute that contains a Map with path variables.HttpServletRequest attribute that contains the path
within the handler mapping, in case of a pattern match, or the full
relevant URI (typically within the DispatcherServlet's mapping) else.IndexDefinition that is based on a property paths.Separator and PathSegment elements.ContentNegotiationStrategy that resolves the file extension in the
request path to a key to be used to look up a media type.IndexResolver implementation considering properties annotated with Indexed or paths set up in
IndexConfiguration.PathIndexResolver with empty IndexConfiguration.PathIndexResolver with given IndexConfiguration.String-based path matching.PathPattern instances that can
then be matched to requests.ResourceResolver that tries to find a resource under the given
locations matching to the request path.RequestMappingInfo.Builder with the given paths.Map method arguments annotated with an @PathVariable
where the annotation does not specify a path variable name.PathVariable.PatternParseException when there is a parse failure.PatternTopic instance.MonoProcessor.UnicodeEscaper that escapes some set of Java characters using the
URI percent encoding scheme.ReactiveStringCommands.BitOpCommand given a RedisStringCommands.BitOperation.RedisConnection.keyCommands().key.key.key.key.key.key.EntityMetadata that assumes the entity handled implements Persistable and uses
Persistable.isNew() for the AbstractEntityInformation.isNew(Object) check.PersistableEntityInformation.IsNewStrategy that invokes Persistable.isNew() on the given object.RepositoryProxyPostProcessor to register a PersistenceExceptionTranslationInterceptor on the
repository proxy.PersistenceExceptionTranslationRepositoryProxyPostProcessor using the given
ListableBeanFactory.Expiration.EntityInformation implementation that uses a PersistentEntity to obtain id type information and uses
a IdentifierAccessor to access the property value if requested.PersistableEntityInformation for the given PersistentEntity.RedisConnection.keyCommands().key in milliseconds.key in milliseconds.key in milliseconds.RedisConnection.keyCommands().key as a UNIX timestamp.key as a UNIX timestamp in milliseconds.key as a UNIX timestamp in milliseconds.key as a UNIX timestamp in milliseconds.RedisConnection.hyperLogLogCommands().RedisConnection.hyperLogLogCommands().RedisConnection.hyperLogLogCommands().null if no references need purging.GenericObjectPoolConfig used by the driver.GenericObjectPoolConfig instead. Will be removed in 1.4.PoolException instance.PoolException instance.ReactiveRedisConnection.KeyCommand.getKey()key.count random members from set at key.key.count random members from set at key.Repositories.Descriptor for a
particular attribute.ManagedAttribute attribute or the ManagedMetric attribute
to the attribute descriptor.TestContext attribute which indicates that
ServletTestExecutionListener has already populated Spring Web's
RequestContextHolder.ModelMBeanInfo instance has been constructed but
before it is passed to the MBeanExporter.Descriptor for an MBean.ManagedResource attribute
to the MBean descriptor.Descriptor for a
particular operation.ManagedAttribute attribute
to the attribute descriptor.Point representation of positions for one or more members.Point representation of positions for one or more members.Point representation of positions for one or more members.Point representation of positions for one or more members.BlockJUnit4ClassRunner.possiblyExpectingExceptions(FrameworkMethod, Object, Statement)
except that the expected exception is retrieved using
SpringJUnit4ClassRunner.getExpectedException(FrameworkMethod).MockHttpServletRequestBuilder for a POST request.MockHttpServletRequestBuilder for a POST request.ResponseEntity.ResponseEntity.ResponseEntity.ResponseEntity.HttpEntity.ResponseEntity.Location header.Location header.Location header.Location header.Location header.Location header.CallMetaDataProvider interface.PostgresSequenceMaxValueIncrementerDataFieldMaxValueIncrementer that retrieves the next value
of a given PostgreSQL sequence.TableMetaDataProvider.POST requests onto specific handler
methods.BeanDefinition and tweak the configuration if necessary.BeanDefinition built from annotations and tweak the configuration if
necessary.BeanDefinition built from XML and tweak the configuration if necessary.ProxyFactory, e.g. add further interceptors to it.Callable has produced a result in the
async thread in which the Callable is executed.DeferredResult has been set, via
DeferredResult.setResult(Object) or
DeferredResult.setErrorResult(Object), and is also ready to
handle the concurrent result.ServletContextAwareProcessor, etc.ServletContextAwareProcessor, etc.HttpUriRequest before it is
returned as part of a HttpComponentsClientHttpRequest.TransactionalProxy to the set of
proxy interfaces in order to avoid re-processing of transaction metadata.MockHttpServletRequest after its creation
and initialization through a MockHttpServletRequestBuilder.Publisher.TestContextManager.prepareTestInstance(java.lang.Object).Sort parameter in the parameters.Pragma header field name.TaskExecutor prefer short-lived tasks over
long-lived tasks?Integer attribute defining the rate of processing in a
component which has capacity to request and hold a backlog of data.JsonPathResultMatchers instance
to verify that the JSON payload is prepended with the given prefix.true.MBeanServerConnection is configured and attempts
to detect a local connection if one is not supplied.NotificationListener.HttpURLConnection.ConfigurableApplicationContext created by this
SmartContextLoader before bean definitions are read.GenericApplicationContext created by this ContextLoader.PreparedStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations.JdbcTemplate class.beforeCommit synchronization callbacks occur.test instance of the supplied
test context by
autowiring
and
initializing
the test instance via its own
application context (without
checking dependencies).test instance of the supplied
test context, for example by injecting dependencies.RequestContextHolder, but only if
the test class is annotated with
@WebAppConfiguration.Connection right after transaction begin.Callable is executed and before the
actual invocation of the Callable.Cache-Control: no-store header.Mono<Principal> to return for this exchange.MvcResult details to the "standard" output stream.MvcResult details to the supplied OutputStream.MvcResult details to a given output
stream — for example: System.out, System.err, a
custom java.io.PrintWriter, etc.ImageReadParam
before it is used to read an image.ImageWriteParam
before it is used to write an image.CorsConfiguration.CdiRepositoryExtensionSupport.repositoryTypes for later registration as bean type.Errors object.ContextConfigurationAttributes for a given test class.ContextLoader SPI, the
default implementation simply delegates to AbstractContextLoader.processLocations(Class, String...),
passing it the declaring class and resource locations retrieved from the supplied
configuration attributes.SmartContextLoaders to process the supplied
ContextConfigurationAttributes.ContextConfigurationAttributes.ContextConfigurationAttributes.RequestDataValueProcessor
instance if one is configured or otherwise returns the same value.@Autowired injection for the given target object,
based on the current web application context.@Autowired injection for the given target object,
based on the current root web application context as stored in the ServletContext.locations are null or empty
and AbstractContextLoader.isGenerateDefaultLocations() returns true,
default locations will be generated (i.e., detected) for the specified class
and the configured resource suffixes;
otherwise, the supplied locations will be
modified if necessary and returned.AbstractDelegatingSmartContextLoader does not support the
ContextLoader.processLocations(Class, String...) method.MergedContextConfiguration instance.WebMergedContextConfiguration if the test class in the
supplied MergedContextConfiguration is annotated with
@WebAppConfiguration and otherwise returns
the supplied instance unmodified.PropertyAccessException to an appropriate
error registered on the given Errors instance.CorsConfiguration.Converter to potentially prepare collection
elements.ProducesRequestCondition.ProducesRequestCondition(String[], String[]) but also
accepting a ContentNegotiationManager.HttpServletRequest attribute that contains the set of
producible MediaTypes applicable to the mapped handler.ProfileValueChecker is a custom JUnit Statement that checks
whether a test class or test method is enabled in the current environment
via Spring's @IfProfileValue annotation.ProfileValueChecker statement.ProfileValueSourceConfiguration is a class-level annotation which
is used to specify what type of ProfileValueSource to use when
retrieving profile values configured via the @IfProfileValue annotation.BeanPostProcessor to modify RequestMappingHandlerAdapter beans in the application
context to get a ProxyingHandlerMethodArgumentResolver configured as first
HandlerMethodArgumentResolver.BeanPostProcessor to augment RequestMappingHandlerAdapter with a
ProxyingHandlerMethodArgumentResolver.HttpMessageConverter implementation to enable projected JSON binding to interfaces annotated with
ProjectedPayload.ProjectingJackson2HttpMessageConverter using a default ObjectMapper.ProjectingJackson2HttpMessageConverter for the given ObjectMapper.RuntimeException that should be propagated
downstream through Subscriber.onError(Throwable).Transactional annotation, corresponding to the
TransactionDefinition interface.TransactionDefinition.PROPAGATION_REQUIRED otherwise.NamedQueries implementation backed by a Properties instance.java.util.Properties,
allowing for pluggable parsing strategies.Property represents a single member variable of a class,
possibly including its accessor methods (getX, setX).PropertyNamingStrategy to
configure the ObjectMapper with.PropertyPlaceholderHelper that uses the supplied prefix and suffix.PropertyPlaceholderHelper that uses the supplied prefix and suffix.HttpMessageConverter that reads and writes com.google.protobuf.Messages
using Google Protocol Buffers.ProtobufHttpMessageConverter.ProtobufHttpMessageConverter with an
initializer that allows the registration of message extensions.ProtobufHttpMessageConverter which enforces the use of Protobuf 3 and
its official library "com.google.protobuf:protobuf-java-util" for JSON processing.ProtobufJsonFormatHttpMessageConverter with default
JsonFormat.Parser and JsonFormat.Printer configuration.ProtobufJsonFormatHttpMessageConverter with the given
JsonFormat.Parser and JsonFormat.Printer configuration.ProtobufJsonFormatHttpMessageConverter with the given
JsonFormat.Parser and JsonFormat.Printer configuration, also
accepting an initializer that allows the registration of message extensionsOutputStream.Writer.Result.Proxy-Authenticate header field name.Proxy-Authorization header field name.@Configuration class that registers the Spring infrastructure beans necessary
to enable proxy-based asynchronous method execution.FactoryBean that creates a java.net.Proxy.HandlerMethodArgumentResolver to create Proxy instances for interface based controller method parameters.PageableHandlerMethodArgumentResolver using the given ConversionService.@Configuration class that registers the Spring infrastructure beans
necessary to enable proxy-based annotation-driven transaction management.ProxyUtils.ProxyDetector registered via Spring factories.RedisConnection.stringCommands()}.Expiration.Expiration.value and expiration in milliseconds for key.value and expiration in milliseconds for key.RedisConnection.keyCommands().RedisConnection.keyCommands().key in milliseconds.key in milliseconds.key in and convert it to the given TimeUnit.key in milliseconds.key in and convert it to the given TimeUnit.ConnectableFlux which shares this Flux sequence and
dispatches values to subscribers in a backpressure-aware manner.ConnectableFlux which shares this Flux sequence and
dispatches values to subscribers in a backpressure-aware manner.Mono for the duration of a function that may transform it and
consume it as many times as necessary without causing multiple subscriptions
to the upstream.WebService annotated beans in the
containing BeanFactory.Flow.Publisher from a FluxApplicationEventPublisher is set.Scheduler
Scheduler.Worker.Scheduler
Scheduler.Worker.value of a hash key at the bound key.String representation of property dot path with given value.value of a hash hashKey.value of a hash hashKey.ApplicationContext instance to the cache
under the given key, potentially honoring a custom eviction policy.ApplicationContext instance to the cache
under the given key, potentially honoring a custom eviction policy.MockHttpServletRequestBuilder for a PUT request.MockHttpServletRequestBuilder for a PUT request.Context that contains all current key/value pairs plus the
given key/value pair.m at the bound key.m.m.value of a hash key only if key does not exist.value of a hash hashKey only if hashKey does not exist.value of a hash hashKey only if hashKey does not exist.PUT requests onto specific handler
methods.MediaType.sortByQualityValue(List).Example instances.QueryMethod.RepositoryQuery creation.QuerydslPredicateArgumentResolver to create Querydsl Predicate instances for Spring MVC
controller methods.HandlerMethodArgumentResolver to allow injection of com.querydsl.core.types.Predicate into Spring MVC
controller methods.QuerydslPredicateArgumentResolver using the given ConversionService.RepositoryFactorySupport.QueryExecutorMethodInterceptor.RepositoryQuerys.QueryMethod from the given parameters.QueryMethodParameterConversionException for the given source object, MethodParameter
and root cause ConversionException.RedirectView.appendQueryProperties(java.lang.StringBuilder, java.util.Map<java.lang.String, java.lang.Object>, java.lang.String).SortQuery implementations.String with single quotes.String with single quotes
if it is a String; keeping the Object as-is else.<radiobuttons> tag renders multiple HTML 'input' tags with type 'radio'.<radiobutton> tag renders an HTML 'input' tag with type 'radio'.Circle.Circle applying RedisGeoCommands.GeoRadiusCommandArgs.Metric.Metric and RedisGeoCommands.GeoRadiusCommandArgs.Circle.Circle applying RedisGeoCommands.GeoRadiusCommandArgs.Metric.Metric and RedisGeoCommands.GeoRadiusCommandArgs.Circle.Circle applying RedisGeoCommands.GeoRadiusCommandArgs.Metric.Metric and RedisGeoCommands.GeoRadiusCommandArgs.RedisConnection.keyCommands().RedisNode.key.key.count random elements from set at the bound key.count random elements from set at key.count random elements from set at key.begin and end from list at the bound key.start and end from sorted set.begin and end from list at key.begin and end from list at key.start and end from sorted set.start and end from sorted set.Range header field name.RedisZSetCommands.Range.getMin() and
RedisZSetCommands.Range.getMax().RedisZSetCommands.Limit.getCount(), starting at
RedisZSetCommands.Limit.getOffset() with lexicographical ordering having a value between RedisZSetCommands.Range.getMin() and
RedisZSetCommands.Range.getMax().key with a value between
Range#getLowerBound() and Range#getUpperBound().RedisZSetCommands.Limit.getCount(), starting at
RedisZSetCommands.Limit.getOffset() with lexicographical ordering from ZSET at key with a value between
Range#getLowerBound() and Range#getUpperBound().key with a value between
RedisZSetCommands.Range.getMin() and RedisZSetCommands.Range.getMax().RedisZSetCommands.Limit.getCount(), starting at
RedisZSetCommands.Limit.getOffset() with lexicographical ordering from ZSET at key with a value between
RedisZSetCommands.Range.getMin() and RedisZSetCommands.Range.getMax().RedisZSetCommands.Range.getMin() and
RedisZSetCommands.Range.getMax().RedisZSetCommands.Limit.getCount(), starting at
RedisZSetCommands.Limit.getOffset() with lexicographical ordering having a value between RedisZSetCommands.Range.getMin() and
RedisZSetCommands.Range.getMax().min and max from sorted set.min and max from sorted set.start to end where score is between min and max from
sorted set.min and max from sorted set.start to end where score is between min and max from
sorted set.RedisZSetCommands.Tuples in range from start to end where score is between min and
max from sorted set.RedisZSetCommands.Tuples in range from start to end where score is between min and
max from sorted set.value in a sorted set.value in a sorted set.value in a sorted set.RedisSerializationContext using a RedisSerializationContext.SerializationPair.raw() serialization pair.RedisSerializationContext.SerializationPair to pass-thru ByteBuffer objects.GEOADD command parameters.GEODIST command parameters.GEOHASH command parameters.GEOPOS command parameters.GEORADIUSBYMEMBER command parameters.GEORADIUS command parameters.ReactiveRedisConnection.Command.Publisher.Publisher.PFADD command parameters.PFCOUNT command parameters.PFMERGE command parameters.EXPIREAT/PEXPIREAT command parameters.EXPIRE/PEXPIRE command parameters.MOVE command parameters.RENAME command parameters.BRPOPLPUSH command parameters.LINDEX command parameters.LINSERT command parameters.LREM command parameters.LSET command parameters.LPOP/RPOP command parameters.LPUSH/RPUSH command parameters.RPOPLPUSH command parameters.DECRBY command parameters.HINCRBY command parameters.INCRBY command parameters.Example instances using a reactive infrastructure.ReactiveRedisConnection.ReactiveRedisConnection.CommandResponse implementation for ByteBuffer responses for absent keys.ReactiveRedisConnection.CommandResponse implementation for Boolean responses.ReactiveRedisConnection.CommandResponse implementation for ByteBuffer responses.ReactiveRedisConnection.Command for key-bound operations.ReactiveRedisConnection.CommandResponse implementation for List responses.ReactiveRedisConnection.CommandResponse implementation for numeric responses.ReactiveRedisTemplate.ReactiveRedisOperations.ReactiveRedisTemplate using given ReactiveRedisConnectionFactory and
RedisSerializationContext.ReactiveRedisTemplate using given ReactiveRedisConnectionFactory and
RedisSerializationContext.ReactiveRepositoryInformation for the given RepositoryMetadata, repository base
class, custom implementation and ConversionService.RedisScripts using reactive infrastructure.SADD command parameters.SDIFF command parameters.SDIFFSTORE command parameters.SINTER command parameters.SINTERSTORE command parameters.SISMEMBER command parameters.SMOVE command parameters.SPOP command parameters.SRANDMEMBER command parameters.SREM command parameters.SUNION command parameters.SUNIONSTORE command parameters.ReactiveCrudRepository to provide additional methods to retrieve entities using the sorting
abstraction.APPEND command parameters.BITCOUNT command parameters.BITOP command parameters.GETBIT command parameters.MSET command parameters.SETBIT command parameters.SET command parameters.SETRANGE command parameters.ZADD command parameters.ZCOUNT command parameters.ZINCRBY command parameters.ZINTERSTORE command parameters.ZRANGEBYLEX/ZREVRANGEBYLEX command parameters.ZRANGE/ZREVRANGE command parameters.ZRANK/ZREVRANK command parameters.ZREM command parameters.ZREMRANGEBYRANK command parameters.ZREMRANGEBYSCORE command parameters.ZSCORE command parameters.ZUNIONSTORE command parameters.Publisher to Java 9+
Flow.Publisher.Scheduler contract and static
registry and factory methods in Schedulers.suppliers and utilities, busy spin utils
WaitStrategy.Tuples provide a type-safe way to specify multiple parameters.ClientHttpConnector.ClientHttpConnector
with default ClientOptions and HTTP compression support enabled.ClientHttpConnector with the given
HttpClientOptions.BuilderHttpHandler to the Reactor Netty channel handling function.ByteBuffer into the according type.ByteBuffer into the according type.HttpMessageReader.read(ResolvableType, ReactiveHttpInputMessage, Map)
with additional context available.AbstractHttpMessageConverter.readInternal(Class, HttpInputMessage).ReadableInstant instances using a DateTimeFormatter.ReadablePartial instances using a DateTimeFormatter.HttpMessageReader.Collection of target objects from the given Resource.AbstractHttpMessageConverter.read(Class, HttpInputMessage).Reader.HttpMessageReader.readMono(ResolvableType, ReactiveHttpInputMessage, Map)
with additional, context available.readonly' attribute.HttpHeaders object that can only be read, not written to.LineNumberReader, using the supplied
comment prefix and statement separator, and build a String containing
the lines.Matcher.String using the given delimiter.Model interface that controllers can use to
select attributes for a redirect scenario.RedirectAttributes.RedisTemplate defining common properties.RedisAtomicDouble instance.RedisAtomicDouble instance.RedisAtomicDouble instance.RedisAtomicDouble instance.RedisAtomicInteger instance.RedisAtomicInteger instance.RedisAtomicInteger instance.RedisAtomicInteger instance.RedisAtomicLong instance.RedisAtomicLong instance.RedisAtomicLong instance.RedisAtomicLong instance.RedisClientInfo provides general and statistical information about client connections.RedisClientInfo from Properties.RedisConnection via RedisConnectionFactory using connecting
to Redis Cluster.RedisClusterConfiguration.RedisClusterConfiguration for given hostPort combinations.RedisClusterConfiguration looking up values in given PropertySource.RedisClusterConnection allows sending commands to dedicated nodes within the cluster.RedisClusterNode with empty RedisClusterNode.SlotRange.RedisClusterNode with an id and empty RedisClusterNode.SlotRange.RedisClusterNode with given RedisClusterNode.SlotRange.RedisClusterNode with given RedisClusterNode.SlotRange.RedisClusterNode.Collection contract.RedisConnection handling, allowing for reuse of instances within
'transactions'/scopes.EntityConverter.RedisCustomConversions object.RedisCustomConversions instance registering the given converters.Bucket representing the domain object to be stored in a Redis hash.Metrics supported by Redis.RedisGeoCommands.GeoLocation representing a Point associated with a name.RedisGeoCommands.RedisHash marks Objects as aggregate roots to be stored in a Redis hash.IndexDefinition implementation.RedisIndexDefinition.Subscription.RedisInvalidSubscriptionException instance.RedisInvalidSubscriptionException instance.RedisKeyExpiredEvent is Redis specific ApplicationEvent published when a specific key in Redis
expires.RedisKeyExpiredEvent.RedisKeyExpiredEventRedisKeyExpiredEventApplicationEvent published when a key expires in Redis.RedisKeyspaceEvent.RedisKeyspaceEvent.KeyValueAdapter implementation.RedisKeyValueAdapter with default RedisMappingContext and default
RedisCustomConversions.RedisKeyValueAdapter with default RedisCustomConversions.RedisKeyValueAdapter.RedisKeyValueAdapter with specific RedisConverter.CdiBean to create RedisKeyValueAdapter instances.RedisKeyValueAdapterBean.KeyValueTemplate.RedisKeyValueTemplate.KeyValueCallback.CdiBean to create RedisKeyValueTemplate instances.RedisKeyValueTemplateBean.List contract.RedisListenerExecutionFailedException instance.RedisListenerExecutionFailedException instance.MappingContext.RedisMappingContext with empty MappingConfiguration.RedisMappingContext.RedisNode.RedisTemplate.PersistentEntity.PersistentProperty implementation.RedisPersistentProperty.RedisPipelineException instance.RedisPipelineException instance using a default message.RedisPipelineException instance using a default message and an empty pipeline result
list.RedisPipelineException instance.Properties extension for a Redis back-store.RedisProperties instance.RedisProperties instance.RedisProperties instance.RedisProperties instance.ImportBeanDefinitionRegistrar.CdiRepositoryBean to create Redis repository instances.CdiRepositoryBean.RepositoryConfigurationExtension for Redis.RepositoryFactorySupport specific of handing Redis
KeyValueRepository.FactoryBean interface to allow easy setup of RedisRepositoryFactory via Spring
configuration.RedisRepositoryFactoryBean for the given repository interface.RedisConnection via RedisConnectionFactory using connecting
to Redis Sentinel(s).RedisSentinelConfiguration.RedisSentinelConfiguration for given hostPort combinations.RedisSentinelConfiguration looking up values in given PropertySource.RedisSerializationContext.Set contract.RedisConnection via RedisConnectionFactory using connecting
to a single node Redis installation.RedisStandaloneConfiguration.RedisStandaloneConfiguration given hostName.SET command arguments for NX, XX.RedisSubscribedConnectionException instance.RedisSubscribedConnectionException instance.RedisTemplate instance.RedisZSetCommands.Range defines min and max values to retrieve from a ZSET.Flux sequence into an single object of the same
type than the emitted items.Flux sequence into an single object matching the
type of a seed value.Flux sequence into an single object matching the
type of a lazily supplied seed value.Subscriber subscribes and disconnects
when all Subscribers cancelled or the upstream source completed.Subscriber subscribes and disconnects
when all Subscribers cancelled or the upstream source completed.Subscriber subscribes.Subscriber subscribes.ReferenceResolver retrieves Objects marked with Reference from Redis.ReferenceResolver using RedisKeyValueAdapter to read raw data.Referer header field name.EntityInformation implementation that inspects fields for an annotation and looks up this field's value to
retrieve the id.ReflectionEntityInformation inspecting the given domain class for a field carrying the
Id annotation.ReflectionEntityInformation inspecting the given domain class for a field carrying the given
annotation.ReflectionTestUtils is a collection of reflection-based utility
methods for use in unit and integration testing scenarios.ReflectionUtils.FieldFilter for a given annotation.ReflectionUtils.FieldFilter that has a description.LoadTimeWeaver which uses reflection to delegate to an underlying ClassLoader
with well-known transformation hooks.MethodResolver used by default in StandardEvaluationContext
unless explicit method resolvers have been specified.PropertyAccessor that uses reflection to access properties
for reading and possibly also for writing.BeanFactoryRefreshableTargetSource that determines whether
a refresh is required through the given ScriptFactory.CdiRepositoryBean for further general treatment by the infrastructure.MBeanServer.MBeanServer.CallableProcessingInterceptor under the given key.CallableProcessingInterceptor without a key.Callable.ServletContextListener that closes the given
application context when the servlet context is destroyed.ContextLoaderListener against the given servlet context.CorsConfiguration for the specified path pattern.CorsConfiguration for the specified path pattern.Map<String, CorsConfiguration> (mapped CorsConfigurations)
under a well-known name unless already registered.DataSource.CodecConfigurer.customCodecs().DeferredResultProcessingInterceptor under the given key.DeferredResultProcessingInterceptors without a specified key.DeferredResult.DispatcherServlet against the given servlet context.AbstractBeanDefinition with the given registry with the given bean name unless the
registry already contains a bean with that name.MethodFilter which will be called during method resolution
for the specified type.RequestDispatcher (typically a MockRequestDispatcher)
that acts as a wrapper for the named Servlet.PathMatcher
under that well-known name, unless already registered.BeanDefinitionRegistry.ScriptFactoryPostProcessor bean definition in the supplied
BeanDefinitionRegistry if the ScriptFactoryPostProcessor hasn't
already been registered.DispatcherServlet as follows:
a default filter name is chosen based on its concrete type
the asyncSupported flag is set depending on the
return value of asyncSupported
a filter mapping is created with dispatcher types REQUEST,
FORWARD, INCLUDE, and conditionally ASYNC depending
on the return value of asyncSupported
If the above defaults are not suitable or insufficient, override this
method and register filters directly with the ServletContext.ScheduledExecutorTasks
on the given ScheduledExecutorService.TestExecutionListeners
by appending them to the list of listeners used by this TestContextManager.TestExecutionListeners
by appending them to the list of listeners used by this TestContextManager.UrlPathHelper
under that well-known name, unless already registered.AbstractBeanDefinition and registers it inside the given
BeanDefinitionRegistry.TestContext attribute which indicates
whether or not the dependencies of a test instance should be
reinjected in
beforeTestMethod().HttpServletResponse.sendRedirect(String) and handles it by
setting the HTTP status and "Location" headers, which keeps the Servlet
container from re-writing relative redirect URLs into absolute ones.connection.ReferenceManager#pollForPurge().JndiTemplate.getContext().RemoteInvocation objects.RemoteInvocation objects.RemoteInvocation on a target object.RemoteInvocation from an AOP Alliance
MethodInvocation.RemoteInvocation objects and serialize
RemoteInvocationResult objects,
for example Spring's HTTP invoker.count occurrences of value from the list stored at the bound key.values from set at the bound key and return the number of removed elements.values from sorted set.path.count occurrences of value from the list stored at key.hashKeys from the hash at key.count occurrences of value from the list stored at key.values from set at key and return the number of removed elements.values from sorted set.values from set at key and return the number of removed elements.values from sorted set.ConfigurableApplicationContext.ConfigurableApplicationContext.Disposable from this container, without disposing it.AbstractHtmlElementBodyTag.doFinally() allowing subclasses to remove any attributes from the
javax.servlet.jsp.PageContext as needed.this key in the PageContext#PAGE_SCOPE.RemoveIndexedData represents a removed index entry from a secondary index for a property path in a given keyspace.requestURI.start and end from sorted set with the bound key.start and end from sorted set with key.start and end from sorted set with key.min and max from sorted set with the bound key.min and max from sorted set with key.min and max from sorted set with key.RedisConnection.keyCommands().sourceKey to targetKey.oleName to newName.oldKey to newKey.oldKey to newKey.oleName to newKey only if newKey does not exist.oleName to newKey only if newKey does not exist.RedisConnection.keyCommands().sourceKey to targetKey only if targetKey does not exist.oleName to newName only if newName does not exist.BodyContent.input(checkbox)' with the supplied value, marking
the 'input' element as 'checked' if the supplied Boolean is
true.input(checkbox)' with the supplied value, marking the
'input' element as 'checked' if the supplied value matches the
bound value.input(checkbox)' with the supplied value, marking the
'input' element as 'checked' if the supplied value matches the
bound value.ScriptTemplateView render function in order to make
the application context, the locale, the template loader and the url available on
scripting side.RenderingContext.Workbook and rendering
it to the given response.SXSSFWorkbook when done with rendering.Flux when a companion sequence emits elements in
response to the flux completion signal.Mono when a companion sequence emits elements in
response to the flux completion signal.Disposable on this container but don't dispose the previous
one (if any).Operators.cancelledSubscription()).ContentNegotiationConfigurer.mediaType(java.lang.String, org.springframework.http.MediaType) but for replacing existing mappings.${name} with the corresponding
property from the supplied Properties.${name} with the value returned
from the supplied PropertyPlaceholderHelper.PlaceholderResolver.Flux into a hot source and cache last emitted signals for further Subscriber.Flux into a connectable hot source and cache last emitted
signals for further Subscriber.Flux into a connectable hot source and cache last emitted signals
for further Subscriber.Flux into a connectable hot source and cache last emitted signals
for further Subscriber.Flux into a connectable hot source and cache last emitted signals
for further Subscriber.Flux into a connectable hot source and cache last emitted signals
for further Subscriber.IllegalArgumentException if the request is null or negative.IllegalStateException that indicates more than the requested
amount was produced.duplicate subscription error.ListableBeanFactory.Repositories instance by looking up the repository instances and meta information from the
given ListableBeanFactory.ApplicationEvent being thrown after a RepositoryPopulator has finished populating the
Repositories available in the ApplicationContext.RepositoryBeanDefinitionParser using the given RepositoryConfigurationExtension.ImportBeanDefinitionRegistrars to enable repositoryBeanNameGenerator to create bean names for Spring Data repositories.fragments.RepositoryConfigurationDelegate for the given RepositoryConfigurationSource and
ResourceLoader and Environment.RepositoryConfigurationExtension to ease the implementation of the interface.RepositoryConfigurationSources.RepositoryConfigurationSourceSupport with the given environment.FactoryBean interface to allow easy setup of repository factories via Spring
configuration.RepositoryFactoryBeanSupport for the given repository interface.EntityInformation and RepositoryInformation as well as the QueryMethods exposed by the
repository.RepositoryComposition.MethodInterceptor intercepts calls to methods of the custom implementation and delegates the to it if
configured.RepositoryFragmentConfiguration given interfaceName and AbstractBeanDefinition of
the implementation.RepositoryComposition.RepositoryFragments.RepositoryFragmentsFactoryBean given fragmentBeanNames.RepositoryInvoker instances for repositories managing a particular domain
type.NamespaceHandler to register BeanDefinitionParsers for repository initializers.MockHttpServletRequestBuilder for a request with the given HTTP method.MockHttpServletRequestBuilder for a request with the given HTTP method.ServerHttpRequest methods.javax.servlet.jsp.PageContext attribute for the
page-level RequestContext instance.RequestDataValueProcessor has been configured.RequestAttribute.@RequestBody or an
HttpEntity method argument.ResponseBodyAdvice with default method implementations.MockHttpServletRequest.ClientHttpRequest.RequestCondition useful when the type of the request
condition is not known ahead of time, e.g. custom condition.RequestContext.LocaleContextHolder and
RequestContextHolder.RequestAttributes object.LocaleContextHolder and
RequestContextHolder.DispatcherServlet.Long attribute exposing the current pending demand of a downstream
component.ResponseActions that also implements
RequestMatcher and ResponseCreator
While ResponseActions is the API for defining expectations this
sub-interface is the internal SPI for matching these expectations to actual
requests and for creating responses.MockRestServiceServer
including its public API (create expectations + verify/reset) along with an
extra method for verifying actual requests.Map method arguments annotated with @RequestHeader.@RequestHeader except for
Map arguments.RequestMappingHandlerAdapter for processing requests
through annotated controller methods.RequestMappingHandlerMapping ordered at 0 for mapping
requests to annotated controllers.RequestMappingInfo instances from type and method-level
@RequestMapping annotations in
@Controller classes.RequestCondition that consists of the following other conditions:
PatternsRequestCondition
RequestMethodsRequestCondition
ParamsRequestCondition
HeadersRequestCondition
ConsumesRequestCondition
ProducesRequestCondition
RequestCondition (optional, custom request condition)
RequestMappingInfo defines
the mapping between a request and a handler method.HandlerMethodMappingNamingStrategy for RequestMappingInfo-based handler
method mappings.MatchableHandlerMapping with a method to further extract
URI template variables from the pattern.RequestMethods.Map method arguments annotated with an @RequestParam
where the annotation does not specify a request parameter name.RequestParam, arguments of
type MultipartFile in conjunction with Spring's MultipartResolver
abstraction, and arguments of type javax.servlet.http.Part in conjunction
with Servlet 3.0 multipart requests.@RequestPart
Of type MultipartFile in conjunction with Spring's MultipartResolver abstraction
Of type javax.servlet.http.Part in conjunction with Servlet 3.0 multipart requests
When a parameter is annotated with @RequestPart, the content of the part is
passed through an HttpMessageConverter to resolve the method argument with the
'Content-Type' of the request part in mind.Request~ and
ResponseBodyAdvice.ServerHttpRequest implementation that accesses one part of a multipart
request.RequestPartServletServerHttpRequest instance.MockHttpServletRequest instance after it has been built
by MockHttpServletRequestBuilder or its subclass
MockMultipartHttpServletRequestBuilder.@RequestBody and handles return
values from methods annotated with @ResponseBody by reading and writing
to the body of the request or response with an HttpMessageConverter.ContentNegotiationManager.@RequestBody method arguments.@RequestBody and handling
@ResponseBody.@RequestScope is a specialization of @Scope for a
component whose lifecycle is bound to the current web request.Scope
implementation.ExecutorService that is used internally
on each subscription.ExecutorService that is used internally
on each subscription.MockRestRequestMatchers.requestTo(URI) that prepares the URI from a URI
template plus optional variables via UriComponentsBuilder
including encoding.HttpServletRequest into a
logical view name when no view name is explicitly supplied.Request an unbounded amount.FreeMarkerView.InternalResourceView.TilesView.requiresScriptedObjectRefresh method.isModified() method).MockFilterChain allowing it to be invoked again.FastByteArrayOutputStream.TestContext attribute which indicates
whether or not the ServletTestExecutionListener should reset Spring Web's
RequestContextHolder in ServletTestExecutionListener.afterTestMethod(TestContext).RedisConnection.serverCommands().RedisConnection.serverCommands().Schedulersreactor Logger factory, by first attempting
to use the SLF4J one, then falling back to either Console logging or
java.util.logging.Logger).key from the onEachOperator hook.Schedulers.onHandleError(BiConsumer) hook to the default no-op behavior.key from the onLastOperator hook.Exceptions.failWithCancel()key from the onOperatorError hook.ByteArrayOutputStream that:
has public ResizableByteArrayOutputStream.grow(int)
and ResizableByteArrayOutputStream.resize(int) methods
to get more control over the size of the internal buffer
has a higher initial capacity (256) by default
As of 4.2, this class has been superseded by FastByteArrayOutputStream
for Spring's internal use where no assignability to ByteArrayOutputStream
is needed (since FastByteArrayOutputStream is more efficient with buffer
resize management but doesn't extend the standard ByteArrayOutputStream).ResizableByteArrayOutputStream
with the default initial capacity of 256 bytes.ResizableByteArrayOutputStream
with the specified initial capacity.HttpMethod.HttpStatus, if possible.ApplicationContext for the given test class.ActiveProfiles.profiles() or ActiveProfiles.value().action' attribute.Pageable method parameter into an argument value from a given request.Sort method parameter into an argument value from a given request.WebArgumentResolver instance.HandlerMethodArgumentResolvers and invoke the one that supports it.ModelAndViewContainer.setRequestHandled(boolean) to
false to indicate that the method signature provides access
to the response.ContextLoader class to use for the
supplied list of ContextConfigurationAttributes and then instantiate
and return that ContextLoader.BindStatus object.AbstractHandlerExceptionResolver.doResolveException(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Object, java.lang.Exception) template method.ModelAndView that represents a specific error page if appropriate.for' attribute value for this tag,
autogenerating one if none specified.id' attribute value for this tag,
autogenerating one if none specified.AbstractMappingContentNegotiationStrategy.resolveMediaTypes(NativeWebRequest) that accepts
an already extracted key.Method to handle the given exception.Method to handle the given exception type.Method to handle the given Throwable.Resolves and returns the name of the form object.MultipartHttpServletRequest
object that provides access to file descriptors and makes contained
parameters accessible via the standard ServletRequest methods.Parameter in the supplied ParameterContext by
retrieving the corresponding dependency from the test's ApplicationContext.${...} placeholders in the given text, replacing them with
corresponding system property values.${...} placeholders in the given text, replacing them with
corresponding system property values.RepositoryQuery from the given QueryMethod that can be executed afterwards.ScriptFactory BeanDefinition.Resource that
exists under one of the given resource locations.Resource that
exists under one of the given resource locations.@ResponseStatus annotation.ResponseStatusException.targetDataSources map, into
the actual lookup key to be used for matching with the
current lookup key.TransactionDefinition interface.ResourceUrlProvider.ResourceAccessException with the given message.ResourceAccessException with the given message and IOException.ApplicationContext implementation
for a JCA ResourceAdapter.FactoryBean that bootstraps
the specified JCA 1.7 javax.resource.spi.ResourceAdapter,
starting it with a local javax.resource.spi.BootstrapContext
and exposing it for bean references.ThemeSource implementation that looks up an individual
ResourceBundle per theme.ViewResolver implementation that uses
bean definitions in a ResourceBundle, specified by the bundle basename.ResourceDatabasePopulator with default settings.ResourceDatabasePopulator with default settings
for the supplied scripts.ResourceDatabasePopulator with the supplied values.ResourceHandlerRegistration instance.ResourceHandlerRegistry.ResourceHandlerRegistry(ApplicationContext, ServletContext, ContentNegotiationManager)
that also accepts the UrlPathHelper used for mapping requests to static resources.TransactionSynchronization implementation that manages a
ResourceHolder bound through TransactionSynchronizationManager.HttpMessageConverter that can read/write Resources
and supports byte range requests.ResourceHttpMessageConverter
that supports read streaming, i.e. can convert an
HttpInputMessage to InputStreamResource.ResourceHttpMessageConverter.HttpMessageWriter that can write a Resource.HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc.ClassLoadHelper interface
onto Spring's ResourceLoader interface.ResourceReaderRepositoryPopulator using the given ResourceReader.BeanDefinitionParser to parse repository initializers.HttpMessageConverter that can write a single ResourceRegion,
or Collections of ResourceRegions.ResourceResolvers where each resolver
is given a reference to the chain allowing it to delegate when necessary.ScriptSource implementation
based on Spring's Resource
abstraction.PlatformTransactionManager
interface, indicating a native resource transaction manager, operating on a single
target resource.ResourceTransformers where each resolver
is given a reference to the chain allowing it to delegate when necessary.ResourceTransformer with an optional helper method
for resolving public links within a transformed resource.HttpServletResponse and overrides its
encodeURL method in order to
translate internal resource request URLs into public URL paths for external
use.ResourceUrlProvider instance it
is configured with as a request attribute.web.xml): "responseEncodedHtmlEscape".HttpServletRequest attribute that contains the response status code.@ResponseBody
or a ResponseEntity controller method but before the body is written
with an HttpMessageConverter.ResponseBodyEmitter and sub-classes
such as SseEmitter including the same types wrapped with
ResponseEntity.ReactiveAdapterRegistry,
SyncTaskExecutor, and
ContentNegotiationManager with an Accept header strategy.HttpCookie subclass with the additional attributes allowed in
the "Set-Cookie" response header.ClientHttpResponse.HttpEntity that adds a HttpStatus status code.ResponseEntity with the given status code, and no body nor headers.ResponseEntity with the given body and status code, and no headers.HttpEntity with the given headers and status code, and no body.HttpEntity with the given body, headers, and status code.@ControllerAdvice classes
that wish to provide centralized exception handling across all
@RequestMapping methods through @ExceptionHandler methods.ResponseEntity.ResponseEntity.RestTemplate to determine
whether a particular response has an error or not.RestTemplate's retrieval methods
Implementations of this interface perform the actual work of extracting data
from a ClientHttpResponse, but don't need to worry about exception
handling or closing resources.ResponseStatus.code() and
ResponseStatus.reason() that should be returned.ResponseStatusException by setting the response status.HandlerExceptionResolver that uses the @ResponseStatus
annotation to map exceptions to HTTP status codes.RestTemplate whenever it encounters
client-side HTTP errors.RestClientException with the given message.RestClientException with the given message and
exception.@Controller and @ResponseBody.@ControllerAdvice
and @ResponseBody.RestGatewaySupport, with default parameters.RestGatewaySupport, with the given ClientHttpRequestFactory.RedisConnection.keyCommands().RestTemplate using default settings.RestTemplate based on the given ClientHttpRequestFactory.RestTemplate using the given list of
HttpMessageConverter to useResultHandler performs a generic action on the result of an
executed request — for example, printing debug information.ResultMatcher matches the result of an executed request against
some expectation.ResultProcessor to expose metadata about query result element projection and eventually post processing raw
query results into projections and data transfer objects.JdbcTemplate's query methods.SqlOutParameter and SqlReturnResultSet.SqlRowSet interface, wrapping a
ResultSet, catching any SQLExceptions and translating
them to a corresponding Spring InvalidResultSetAccessException.SqlRowSetMetaData interface, wrapping
a ResultSetMetaData instance, catching any SQLExceptions
and translating them to a corresponding Spring InvalidResultSetAccessException.exception, which is presumably the
target exception of an InvocationTargetException.exception, which is presumably the
target exception of an InvocationTargetException.@SessionAttributes or attributes previously stored
in the model that matched by type.DataSource to use for the supplied test context.ScriptEngine from the given ScriptEngineManager
by name, delegating to ScriptEngineManager.getEngineByName(java.lang.String) but
throwing a descriptive exception if not found or if initialization failed.ContextCache.ProfileValueSource type for the specified
test class as configured via the
@ProfileValueSourceConfiguration annotation and instantiates a new
instance of that type.retry field.retry field of this event, if available.Flux sequence if it signals any error, indefinitely.Flux sequence if it signals any error, for a fixed
number of times.Mono sequence if it signals any error, indefinitely.Mono sequence if it signals any error, for a fixed
number of times.Retry-After header field name.QueryMethod.RowMapper.ExchangeResult with the
raw response content.ExchangeResult with the
decoded response content.WebTestClient.ResponseSpec.returnResult(Class) that accepts information
about a target type with generics.ReactiveZSetCommands.ZIncrByCommand given a member to obtain its reversed rank (ordering high
to low).start to end from sorted set ordered from high to low.start to end from sorted set ordered from high to low.start to end from sorted set ordered from high to low.key with a value between
Range#getLowerBound() and Range#getUpperBound().RedisZSetCommands.Limit.getCount(), starting at
RedisZSetCommands.Limit.getOffset() with reverse lexicographical ordering from ZSET at key with a value
between Range#getLowerBound() and Range#getUpperBound().min and max from sorted set ordered from high to low.min and max from sorted set ordered from high to low.start to end where score is between min and max from
sorted set ordered high -> low.min and max from sorted set ordered from high to low.start to end where score is between min and max from
sorted set ordered high -> low.RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to
low.RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to
low.RedisZSetCommands.Tuple in range from start to end where score is between min and
max from sorted set ordered high -> low.RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to
low.RedisZSetCommands.Tuple in range from start to end where score is between min and
max from sorted set ordered high -> low.RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.value in a sorted set when scored high to low.value in a sorted set when scored high to low.value in a sorted set when scored high to low.ReactiveZSetCommands.ZRangeByScoreCommand given a Range to obtain elements ordered from the highest to
the lowest score.ReactiveZSetCommands.ZRangeByLexCommand given a Range of String to obtain elements in reverse
lexicographical ordering.ReactiveZSetCommands.ZRangeCommand given a Range to obtain elements ordered from the highest to the
lowest score.Revisions.ReactiveListCommands.BPopCommand for right push (BRPOP).ReactiveListCommands.PopCommand for right push (RPOP).ReactiveListCommands.PushCommand for right push (RPUSH).key.key.key.key.sourceKey, append it to destinationKey and return its value.srcKey, append it to dstKey and return its value.sourceKey, append it to destinationKey and return its value.srcKey, append it to dstKey and return its value.value to the bound key.values to the bound key before value.value to key.values to key before value.value to key.values to key before value.values to the bound key.values to key.values to key.values to key.values to key.values to the bound key only if the list exists.values to key only if the list exists.values to key only if the list exists.MethodInterceptor for accessing conventional
RMI services or RMI invokers.FactoryBean for RMI proxies, supporting both conventional RMI services
and RMI invokers.FactoryBean that locates a Registry and
exposes it for bean references.Descriptor.Descriptor.Descriptor.@Rollback is a test annotation that is used to indicate whether
a test-managed transaction should be rolled back after
the test method has completed.rollback rule for
RuntimeExceptions.RuntimeException), assuming an unexpected outcome outside of any
business rules.RollbackRuleAttribute class.RollbackRuleAttribute class
for the given exceptionName.JdbcTemplate for processing rows of a
ResultSet on a per-row basis.JdbcTemplate for mapping rows of a
ResultSet on a per-row basis.RedisConnection.listCommands()}.key.key.RedisConnection.listCommands()}.ReactiveRedisConnection.KeyCommand.getKey(), append it to
ReactiveListCommands.RPopLPushCommand.getDestination() and return its value.srcKey, append it to dstKey and return its value.srcKey, append it to dstKey and return its value.RedisConnection.listCommands()}.values to key.values to key.RedisConnection.listCommands()}.values to key only if the list exists.values to key only if the list exists.HttpMessageConverter
that can read and write RSS feeds.callback to execute the actual test
and then tracks the exception thrown during test execution, if any.RunAfterTestClassCallbacks is a custom JUnit Statement which allows
the Spring TestContext Framework to be plugged into the JUnit execution chain
by calling afterTestClass() on the supplied
TestContextManager.RunAfterTestClassCallbacks statement.RunAfterTestExecutionCallbacks is a custom JUnit Statement
which allows the Spring TestContext Framework to be plugged into the
JUnit 4 execution chain by calling afterTestExecution() on the supplied TestContextManager.RunAfterTestExecutionCallbacks statement.RunAfterTestMethodCallbacks is a custom JUnit Statement which allows
the Spring TestContext Framework to be plugged into the JUnit execution chain
by calling afterTestMethod() on the supplied
TestContextManager.RunAfterTestMethodCallbacks statement.@AfterTransaction methods for the
specified test context.RunBeforeTestClassCallbacks is a custom JUnit Statement which allows
the Spring TestContext Framework to be plugged into the JUnit execution chain
by calling beforeTestClass() on the
supplied TestContextManager.RunBeforeTestClassCallbacks statement.RunBeforeTestExecutionCallbacks is a custom JUnit Statement
which allows the Spring TestContext Framework to be plugged into the
JUnit 4 execution chain by calling beforeTestExecution() on the supplied TestContextManager.RunBeforeTestExecutionCallbacks statement.RunBeforeTestMethodCallbacks is a custom JUnit Statement which allows
the Spring TestContext Framework to be plugged into the JUnit execution chain
by calling beforeTestMethod() on the supplied TestContextManager.RunBeforeTestMethodCallbacks statement.@BeforeTransaction methods for the
specified test context.BlockJUnit4ClassRunner.runChild(FrameworkMethod, RunNotifier),
except that tests are determined to be ignored by
SpringJUnit4ClassRunner.isTestMethodIgnored(FrameworkMethod).SqlQuery.findObject(Object[]) method.RunPrepareTestInstanceCallbacks is a custom JUnit Statement which
allows the Spring TestContext Framework to be plugged into the JUnit
execution chain by calling prepareTestInstance() on the supplied TestContextManager.RunPrepareTestInstanceCallbacks statement.RxJava2CrudRepository to provide additional methods to retrieve entities using the sorting
abstraction.RedisConnection.setCommands()}.ReactiveSetCommands.SAddCommand.getValues() to set at ReactiveRedisConnection.KeyCommand.getKey().values to set at key.values to set at key.URLEncoder.Flux then skip the values that follow
within a given duration.Flux then skip the values that follow
before the next signal from a companion sampler Publisher.Flux only if there were no new values emitted
during the window defined by a companion Publisher derived from that particular
value.Flux only if there were no new values emitted
during the window defined by a companion Publisher derived from that particular
value.RedisConnection.serverCommands().RedisConnection.serverCommands()."output"
FlashMap, updates it with the path and query params of the target URL,
and then saves it using the FlashMapManager.RedisConnection.keyCommands().Cursor to iterate over keys.Cursor to iterate over entries in the hash.Cursor to iterate over entries in hash at key.key.key.Flux values with an accumulator BiFunction and
also emit the intermediate results of this function.Flux values with an accumulator BiFunction and
also emit the intermediate results of this function.attribute, returning an
associated value specific to that component, or the default value associated with
the key, or null if the attribute doesn't make sense for that particular component
and has no sensible default.Cursor implementation continuously loading additional results from Redis server until
reaching its starting point zero.ScanCursor with id=0.ScanCursor with ScanOptions.NONEScanCursorScanIteration holds the values contained in Redis Multibulk reply on exectuting SCAN
command.Scannable attributes, which all can define a meaningful
default.Tokens.Scanner implementations in case of malformed
input.ScanOptions.ScanOptionsBuilder.attribute.Flux values with the help of an accumulator BiFunction
and also emits the intermediate results.RedisConnection.setCommands()}.ReactiveRedisConnection.KeyCommand.getKey().key.key.Runnable, invoking it whenever the trigger
indicates a next execution time.Runnable, invoking it at the specified execution time.Runnable, invoking it at the specified execution time.Runnable, invoking it at the specified execution time
and subsequently with the given period.Runnable, invoking it at the specified execution time
and subsequently with the given period.Runnable, starting as soon as possible and
invoking it with the given period.Runnable, starting as soon as possible and
invoking it with the given period.Scheduled
to be invoked by a TaskScheduler according
to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.FactoryBean that sets up
a ScheduledExecutorService
(by default: a ScheduledThreadPoolExecutor)
and exposes it for bean references.Runnable and a delay plus period.MethodInvokingRunnable meant to be used for processing
of no-arg scheduled methods.TaskScheduler, typically using cron
expressions.ScheduledTaskRegistrar.scheduleFixedDelayTask(FixedDelayTask)ScheduledTaskRegistrar.scheduleFixedRateTask(FixedRateTask)org.quartz.Scheduler instance.org.quartz.Scheduler instance.FactoryBean that creates and configures a Quartz org.quartz.Scheduler,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection.Schedulers provides various Scheduler factories useable by publishOn or subscribeOn :
Schedulers.fromExecutorService(ExecutorService)}.Scheduled annotations.Runnable, invoking it at the specified execution time
and subsequently with the given delay between the completion of one execution
and the start of the next.Runnable, invoking it at the specified execution time
and subsequently with the given delay between the completion of one execution
and the start of the next.Runnable, starting as soon as possible and invoking it with
the given delay between the completion of one execution and the start of the next.Runnable, starting as soon as possible and invoking it with
the given delay between the completion of one execution and the start of the next.@Configuration class that registers a ScheduledAnnotationBeanPostProcessor
bean capable of processing Spring's @Scheduled annotation.Configuration classes annotated
with @EnableScheduling.TaskExecutor extension exposing
scheduling characteristics that are relevant to potential task submitters.null to clear the scheme of this builder.value from sorted set with key the bound key.value from sorted set with key key.value from sorted set with key key.ReactiveZSetCommands.ZIncrByCommand given a member.ReactiveZSetCommands.ZScoreCommand given a member.ReactiveZSetCommands.ZCountCommand given a Range.ReactiveZSetCommands.ZRangeByScoreCommand given a Range to obtain elements ordered from the lowest to
the highest score.ReactiveZSetCommands.ZRemRangeByScoreCommand given a Range.ScriptException.ScriptException.RedisScriptsRedisConnection.scriptingCommands().scriptSha exist in script cache.scriptShas exist in script cache.scriptShas exist in script cache.Object.BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it.RedisConnection.scriptingCommands().RuntimeException thrown when issues occur with RedisScriptsScriptingException instance.ScriptingException instance.RedisConnection.scriptingCommands().RedisConnection.scriptingCommands().ScriptUtils if an SQL script cannot be properly parsed.ScriptParseException.ScriptParseException.ScriptUtils if a statement in an SQL script failed when
executing it against the target database.ScriptStatementFailedException.ScriptEngine for automatic lookup in a web environment.ScriptTemplateConfig for creating
a ScriptEngine for use in a web application.ScriptTemplateConfigurer bean.AbstractUrlBasedView subclass designed to run any template library
based on a JSR-223 script engine.UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of it.view class to ScriptTemplateViewResolver.requiredViewClass():
by default ScriptTemplateView.RedisConnection.setCommands()}.ReactiveSetCommands.SInterCommand.getKeys().keys.keys.RedisConnection.setCommands()}.keys and store result in destKey.keys and store result in destKey.Expiration with TimeUnit.SECONDS.seconds to the given TimeUnit.Converter to convert from seconds to the given TimeUnit.ServletRequest indicating use of a
secure channel, such as HTTPS.dbIndex.MediaType selected during content negotiation,
which may be more specific than the one the View is configured with.AdviceMode.AdviceMode.<select> tag renders an HTML 'select' element.ObjectNames to the MBeanExporter.ResponseBodyEmitter.send(Object) that also accepts a MediaType
hint for how to serialize the given Object.Notification using the wrapped
ModelMBean instance.Notification to all registered
NotificationListeners.SerializationException instance.SerializationException instance.FluxProcessor that safely gates multi-threaded producer
Subscriber.onNext(Object).Subscriber by making sure onNext signals are delivered
sequentially (serialized).Server header field name.MBeanServer instance being used to register beans.CodecConfigurer for HTTP message reader and writer
options relevant on the server side.CodecConfigurer.DefaultCodecs extension with extra client-side options.RedisServerCommands.HttpStatus.INTERNAL_SERVER_ERROR that exposes extra
information about a controller method that failed, or a controller method
argument that could not be resolved.Method and an optional cause.MethodParameter and an optional cause.ServerHttpRequest.ServerHttpRequest and delegates all methods to it.ServerHttpResponse and delegates all methods to it.SseEvent.Decoder to use for Server-Sent Events.Encoder to use for Server-Sent Events.ServerSentEvents and also plain
Objects which is the same as an ServerSentEvent with data only.Decoder.Decoder for decoding to Objects.HttpMessageWriter for "text/event-stream" responses.Encoder.Encoder for encoding objects.ServerWebExchange.ServerWebExchange.MethodParameter.ServletConfig (typically determined by the WebApplicationContext)
that it runs in.PropertySource that reads init parameters from a ServletConfig object.FactoryBean that fetches a specific, existing ServletContext attribute.ServletContext (typically determined by the WebApplicationContext)
that it runs in.BeanPostProcessor
implementation that passes the ServletContext to beans that implement
the ServletContextAware interface.LiveBeansView subclass which looks for all ApplicationContexts
in the web application, as exposed in ServletContext attributes.FactoryBean that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in web.xml).PropertySource that reads init parameters from a ServletContext object.Resource implementation for
ServletContext resources, interpreting
relative paths within the web application root directory.PathMatchingResourcePatternResolver,
able to find matching resources below the web application root directory
via ServletContext.getResourcePaths(java.lang.String).Scope wrapper for a ServletContext, i.e. for global web application attributes.AbstractCookieValueMethodArgumentResolver
that resolves cookie values from an HttpServletRequest.HttpHandler to an HttpServlet using Servlet Async
support and Servlet 3.1 non-blocking I/O.InvocableHandlerMethod with the ability to handle return
values through a registered HandlerMethodReturnValueHandler and
also supports setting the response status based on a method-level
@ResponseStatus annotation.HandlerMethod.ModelAttributeMethodProcessor that applies data
binding through a WebDataBinder of type ServletRequestDataBinder.PathExtensionContentNegotiationStrategy that also uses
ServletContext.getMimeType(String) to resolve file extensions.RequestAttributes interface.DataBinder to perform data binding
from servlet request parameters to JavaBeans, including support for multipart files.ServletRequestDataBinder.WebRequest
ServletRequest
MultipartRequest
HttpSession
PushBuilder (as of Spring 5.0 on Servlet 4.0)
Principal
InputStream
Reader
HttpMethod (as of Spring 4.0)
Locale
TimeZone (as of Spring 4.0)
ZoneId (as of Spring 4.0 and Java 8)
ServerHttpAsyncRequestControl to use on Servlet containers (Servlet 3.0+).ServletServerHttpRequest and ServletServerHttpResponse
respectively.ServerHttpRequest implementation that is based on a HttpServletRequest.HttpServletRequest.ServerHttpResponse implementation that is based on a HttpServletResponse.HttpServletResponse.TestExecutionListener which provides mock Servlet API support to
WebApplicationContexts loaded by the Spring
TestContext Framework.AbstractWebArgumentResolverAdapter
that creates a NativeWebRequest from ServletRequestAttributes.WebRequest adapter for an HttpServletRequest.Matcher.SessionAttribute.@SessionAttributes.FlashMap instances to and from the HTTP session.LocaleResolver implementation that
uses a locale attribute in the user's session in case of a custom setting,
with a fallback to the specified default locale or the request's
accept-header locale.WebSessionManager to set on the
WebServerExchange.@SessionScope is a specialization of @Scope for a
component whose lifecycle is bound to the current web session.Scope
implementation.SessionStatus argument by obtaining it from
the ModelAndViewContainer.ThemeResolver implementation that
uses a theme attribute in the user's session in case of a custom setting,
with a fallback to the default theme.RedisConnection.stringCommands()}.RedisConnection.stringCommands()}.ReactiveStringCommands.SetCommand.ReactiveStringCommands.SetCommand given a key.value for key.value for key applying timeouts from expiration if set and inserting/updating values
depending on option.value for key.value for key applying timeouts from expiration if set and inserting/updating values
depending on option.value list element at index.value for the bound key.value and expiration timeout for the bound key.offset with given value.value list element at index.value list element at index.value for key.value and expiration timeout for key.key starting at the specified offset with given value.value for key.value and expiration timeout for key.key starting at the specified offset with given value.Operators.cancelledSubscription())
or was concurrently updated before.Set-Cookie header field name.Set-Cookie2 header field name.Accept header.Accept-Charset header.acceptCharset' attribute.HttpHeaders.setAcceptLanguage(List) using Locale's.Access-Control-Allow-Credentials response header.Access-Control-Allow-Headers response header.Access-Control-Allow-Methods response header.Access-Control-Allow-Origin response header.Access-Control-Expose-Headers response header.Access-Control-Max-Age response header.Access-Control-Request-Headers request header.Access-Control-Request-Method request header.accesskey' attribute.action' attribute.XmlAdapters to be registered with the JAXB Marshaller
and UnmarshallerMBeanServer to locate.MBeanServer to locate.MBeanServer to locate.HTTP methods,
as specified by the Allow header.alt' attribute.WebContentGenerator.setCacheControl(org.springframework.http.CacheControl)UrlPathHelper.UrlPathHelper.UrlPathHelper.UrlPathHelper.ServletContext.getContextPath().AnnotationIntrospector for both serialization and deserialization.ApplicationContext in order to autowire Jackson handlers
(JsonSerializer, JsonDeserializer, KeyDeserializer,
TypeResolverBuilder and TypeIdResolver).ApplicationContext is optional: If set, registered
tasks will be activated in the ContextRefreshedEvent phase;
if not set, it will happen at ScheduledAnnotationBeanPostProcessor.afterSingletonsInstantiated() time.ApplicationContext to be used by this test instance,
provided via ApplicationContextAware semantics.ApplicationContext to be used by this test instance,
provided via ApplicationContextAware semantics.ApplicationContext associated with the web application,
if it was initialized with one via
WebHttpHandlerBuilder#applicationContext.ApplicationContext, e.g. for resource loading.ApplicationContextAware to inject the current
application context.ApplicationContext reference to expose in the
SchedulerContext, for example "applicationContext".MBeanInfoAssembler interface to use
for this exporter.HttpAsyncClient used for
synchronous execution.HttpRequests.AsyncWebRequest to use.context ClassLoader for the
managed resources ClassLoader before allowing the invocation to occur.context ClassLoader for the
managed resources ClassLoader before allowing the invocation to occur.java.util.Properties object.java.util.Properties object,
for all views returned by this resolver.JmxAttributeSource implementation to use for
reading the metadata from the bean class.JmxAttributeSource interface to use
when reading the source-level metadata.Authenticator to be
applied to all detected WebService annotated beans.Authenticator to be
applied to all locally registered contexts.autocomplete' attribute.autocomplete' attribute.MapperFeature.AUTO_DETECT_FIELDS option.MapperFeature.AUTO_DETECT_SETTERS/
MapperFeature.AUTO_DETECT_GETTERS/MapperFeature.AUTO_DETECT_IS_GETTERS
options.byte[] properties when reading and
writing JSON.ResourceBundle conventions.ResourceBundle
conventions.ClassLoader to be used for the default JdkSerializationRedisSerializer in case no other
RedisSerializer is explicitly set as the default one.JaxWsPortProxyFactoryBean subclass.BeanFactory to be used when looking up executors by qualifier.BeanFactory available is optional; if not set,
SchedulingConfigurer beans won't get autodetected and
a scheduler has to be explicitly configured.PlatformTransactionManager will be fetched from the BeanFactory.BeanFactory to use for resolving an executor name.ConfigurableBeanFactory is expected for resolving expressions
in method argument default values.BeanNameGenerator for use with AnnotatedBeanDefinitionReader
and/or ClassPathBeanDefinitionScanner.Map of beans to be registered with the JMX
MBeanServer.@ModelAttribute(binding=true/false) declaration.@ModelAttribute declaration.PropertyAccessExceptions.PropertyAccessExceptions.BindingType annotation.RedisConnection.stringCommands()}.offset in value stored at key.offset in value stored at key.offset in value stored at key.offset in value stored at key.WorkManagerTaskExecutor.execute(java.lang.Runnable) block until the work
has been completed.WorkManagerTaskExecutor.execute(java.lang.Runnable) block until the work
has been actually started.BootstrapContext to be used by this bootstrapper.ClassLoader to load resource bundles with.CacheControl instance as the
new value of the Cache-Control header.Cache-Control header.CacheControl which should be used
by the resource handler.CacheControl instance to build
the Cache-Control HTTP response header.AntPathMatcher.match(java.lang.String, java.lang.String) method.CacheControl
should be used.@SessionAttributes annotated handlers
for the given number of seconds.Templates instance.null should be cached and
automatically resolved to null subsequently.CallableProcessingInterceptor's to register on async requests.ScriptTemplateConfigurer.setCharset(Charset) documentation.Jaxb2Marshaller.supports(Class) should check for
@XmlRootElement annotations.XMLClassDescriptorResolver to be used during unmarshalling.@ContextConfiguration.ClassFilter to use for this pointcut.ClassFilter to use for this pointcut.RedisConnection.serverCommands().JedisClientConfiguration.ClientResources to reuse the client infrastructure.ClientResources using LettuceClientConfiguration.Clock to use to set lastAccessTime on every created
session and to calculate if it is expired.ServerCodecConfigurer.cols' attribute.ReactiveSetCommands.RedisSetCommands.ForkJoinPool.Difference.toString(org.xmlunit.diff.ComparisonFormatter).HttpMessage.getHeaders() to the underlying HTTP message (if not
applied already).Executor to delegate to.RedisConnection.serverCommands().RedisConnection.serverCommands().param to value.param to value.param to value.StaticWebApplicationContext class does not support this method.StaticWebApplicationContext class does not support this method.Connection header.Connection header.MBeanServer
at creation time ("true") or the first time it is invoked ("false").Content-Disposition header when creating a
"multipart/form-data" request.Locale of the content language,
as specified by the Content-Language header.Content-Length header.ContentNegotiationManager to use to determine requested media types.ContentNegotiationManager to use to determine requested media types.ContentNegotiationManager to use to determine requested media types.ContentNegotiationManager to help determine the
media types for resources being served.ContentNegotiationManager to use to determine requested media types.Content-Type header.WebApplicationContext from which to load the delegate Filter bean.WebApplicationContext that this servlet is supposed to use.ApplicationContextInitializer class
names, per the optional "contextInitializerClasses" servlet init-param.ApplicationContextInitializer instances should be used
to initialize the application context used by this ContextLoader.ApplicationContextInitializer instances should be used
to initialize the application context used by this FrameworkServlet.HttpHandlers
for specific context paths.ControllerAdvice
instances to be used in tests (specified Class will be turned into instance).ConversionService for binding JDBC values to bean properties,
or null for none.ConversionService for converting a fetched value.ConverterLookup to use.ConverterRegistry to use.Converters or SingleValueConverters to be registered
with the XStream instance.CorsProcessor to use to apply the matched
CorsConfiguration for a request.CorsProcessor to use to apply the matched
CorsConfiguration for a request.createBlob /
createClob methods.ObjectMapper has been set, a XmlMapper
will be created using its default constructor.CronTask objects.class' attribute.style' attribute.CustomConversions to be applied.RequestMappingHandlerMapping.JMXConnectorServer should be
started as daemon threads.RedisSentinelConfiguration or
RedisStandaloneConfiguration.DatabasePopulator to execute during the bean destruction
phase, cleaning up the database and leaving it in a known state for others.DatabasePopulator to execute during the bean initialization phase.WebDataBinderFactory to be passed to argument resolvers allowing them to create
a WebDataBinder for data binding and type conversion purposes.DataSource for the database to populate when this component
is initialized and to clean up when this component is shut down.DataSource to obtain connections from.DataSource to be used by the Scheduler.DataSource, typically provided via Dependency Injection.DataSource, typically provided via Dependency Injection.DataSource instance that
connects to the embedded database.DataSource instance that
connects to the embedded database.targetDataSources map.Date header.DateFormat.SimpleDateFormat-style pattern.LocalDate objects.LocalDate objects.LocalDateTime objects.Content-Type to be used for writing.ContentNegotiationStrategy to use to determine
the content type to use when no content type is requested.MBeanServer,
to be passed to MBeanServerFactory.createMBeanServer()
or MBeanServerFactory.findMBeanServer().MimeMessages
created by this instance.FileTypeMap to use for
MimeMessages created by this instance.ResourceBundle.Servlet.Connection, e.g.TypeResolverBuilder to use for Jackson's default typing.XmlMapper).MapperFeature.DEFAULT_VIEW_INCLUSION option.ViewResolver chain.DeferredResultProcessingInterceptor's to register on async requests.org.apache.tiles.definition.DefinitionsFactory implementation to use.false - the default), or the specifically generated values (true).input type="checkbox/radio"' tag.dir' attribute.disabled' attribute.disabled' attribute.disabled' attribute.disabled' attribute.disabled' attribute.GsonBuilder#disableHtmlEscaping() when writing
JSON.FrameworkServlet.doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) method.FrameworkServlet.doService(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) method.input type="checkbox/radio"' tag.KeyExpirationEventMessageListener.true RedisTemplate will use MULTI...EXEC|DISCARD to keep track of operations.JsonEncoding for this view.EncodingMode to use when building URIs.enctype' attribute.TransactionDefinition.isReadOnly()
through an explicit statement on the transactional connection:
"SET TRANSACTION READ ONLY" as understood by Oracle, MySQL and Postgres.ScriptEngine to use by the view.ScriptTemplateConfigurer.setEngine(ScriptEngine) documentation.ScriptEngine.ScriptTemplateConfigurer.setEngineName(String) documentation.ObjectNames
generated by the configured ObjectNamingStrategy for
runtime-registered MBeans (MBeanExporter.registerManagedResource(java.lang.Object)) should get
modified: to ensure uniqueness for every instance of a managed Class.EntityResolver to be used during unmarshalling.JMXConnectorServer
as java.util.Properties (String key/value pairs).JMXConnector
as java.util.Properties (String key/value pairs).Environment that this filter runs in.Environment that this servlet runs in.JMXConnector
as a Map of String keys and arbitrary Object values.JMXConnector
as a Map of String keys and arbitrary Object values.ErrorHandler strategy.ErrorHandler strategy.ErrorHandler strategy.ErrorListener
interface for custom handling of transformation errors and warnings.ErrorListener
interface for custom handling of transformation errors and warnings.DeferredResult and handle it.ETag header.EvaluationContextProvider to be used to evaluate SpEL expressions in manually defined queries.EvaluationContextProvider to be used to evaluate SpEL expressions in manually defined queries.RedisConnection.stringCommands()}.Expiration.Expiration.value and expiration in seconds for key.value and expiration in seconds for key.AsyncUncaughtExceptionHandler to use to handle uncaught
exceptions thrown by asynchronous method executions.Executor to use when invoking methods asynchronously.Expires header.Expires header.RedisCallback code.thread context ClassLoader before
allowing any invocations on the MBean to occur.exposeModelAttributes flag which denotes whether
or not model attributes should be exposed as HTTP query parameters.Scheduler instance in the
Quartz SchedulerRepository.JsonFactory to be used to create the ObjectMapper
instance.SerializationFeature.FAIL_ON_EMPTY_BEANS option.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES option.KeySpaceResolver to be used if not explicit key space is annotated to the domain type.Pageable to be used as fallback in case no PageableDefault or
PageableDefault (the latter only supported in legacy mode) can be found at the method parameter to be
resolved.Sort to be used as fallback in case no SortDefault or SortDefault.SortDefaults (the
latter only supported in legacy mode) can be found at the method parameter to be resolved.SQLStateSQLExceptionTranslator).name/type
on the provided targetObject/targetClass to the supplied
value.field object on the
specified target object to the specified value.FileTypeMap to use
for determining the content type of inline content and attachments
that get added to the message.@JsonFilter annotated POJO.Filters to be
applied to all detected WebService annotated beans.Filters to be
applied to all locally registered contexts.IntervalTask objects.IntervalTask objects.FlashMap is saved
(at request completion) and before it expires.for' attribute.encoding of this filter
is supposed to override existing request and response encodings.first and last links to the PagedResources created.encoding of this filter
is supposed to override existing request encodings.encoding of this filter
is supposed to override existing response encodings.FormattingConversionServiceFactoryBean.setConverters(Set) and FormattingConversionServiceFactoryBean.setFormatters(Set).JMXConnectorServer.Configuration.setSettings method.Configuration.setAllSharedVariables() method.generateUniqueDatabaseName flag to enable or disable
generation of a pseudo-random unique ID to be used as the database name.Gson instance to use.NotificationBroadcaster when notifying
any NotificationListener.JsonSerializer, JsonDeserializer, KeyDeserializer,
TypeResolverBuilder and TypeIdResolver).HandlerMethodArgumentResolvers to use to use for resolving method argument values.HandlerMethodReturnValueHandler instances to use to
handle return values.Host header.RedisStandaloneConfiguration.RedisStandaloneConfiguration.HttpComponentsAsyncClientHttpRequestFactory.setAsyncClient(HttpAsyncClient)HttpClient used for
synchronous execution.HttpClient instance to use for this request executor.id' attribute.IDResolver to be used during unmarshalling.value if the bound key is absent.key to hold the string value if key is absent.key to hold the string value if key is absent.If-Match header.If-Match header.If-Modified-Since header.If-None-Match header.If-None-Match header.key to hold the string value if key is present.If-Unmodified-Since header.Unmarshaller should ignore attributes that do not match a specific field.Unmarshaller should ignore elements that do not match a specific field.DROP statement can be ignored.Class instances
mapped to comma separated collection field names.SerializationFeature.INDENT_OUTPUT option.@InitBinder methods.UnsupportedOperationException.Connection constants
(equivalent to the corresponding Spring
TransactionDefinition constants).TransactionDefinition, e.g.input type="checkbox/radio"' tag.option' tag.option' tag.Collection, Map or array of objects
used to generate the 'input type="checkbox/radio"' tags.value' attribute
of the 'input type="checkbox/radio"' tag.value'
attribute of the 'option' tag.value'
attribute of the 'option' tag.Session.JAXBContext properties.JndiObjectFactoryBean.RdbmsOperation.setDataSource(javax.sql.DataSource) when you want to
use the same JdbcTemplate in multiple RdbmsOperations.ThreadFactory to delegate to,
replacing the default JNDI name "java:comp/DefaultManagedThreadFactory".Executor to delegate to,
replacing the default JNDI name "java:comp/DefaultManagedExecutorService".Executor to delegate to,
replacing the default JNDI name "java:comp/DefaultManagedScheduledExecutorService".JobFactory to use for this Scheduler.Jsonb instance to use.label' attribute.<option> tag.lang' attribute.Last-Modified header.JAXBContext for this marshaller.MBeanExporterListeners that should be notified
of MBean registration and unregistration events.Locale to use for formatting.HttpSession,
holding the current Locale value.LocaleContextResolver.MBeanServerFactoryBean should attempt
to locate a running MBeanServer before creating one.Location header.NamedQueries instance.@ContextConfiguration.List of Resource locations to use as sources
for serving static resources.ResourceHttpRequestHandler.setLocations(List) that accepts a list of
String-based location values, with support for UrlResource's
(e.g. files or HTTP URLs) with a special prefix to indicate the charset
to use when appending relative paths.ClassLoader.ObjectName-style name of the single MBean
that the encapsulated NotificationFilter
will be registered with to listen for Notifications.ObjectName-style names of the MBeans
that the encapsulated NotificationFilter
will be registered with to listen for Notifications.ObjectMapper to be used.Mapper to use.MapperWrapper classes.MappingContext to be used to lookup PersistentEntity instances for
RepositoryFactoryBeanSupport.getPersistentEntity().Resource from which mappings are loaded.mime.types file format, as specified by the
Java Activation Framework, for example:text/html html htm HTML HTMxsi:type attribute.Marshaller to be used by this message converter.Marshaller to be used by this view.Marshaller.Listener to be registered with the JAXB Marshaller.Marshaller properties.MarshallingStrategy to use.PathPattern produced by this parser should should
automatically match request paths with a trailing slash.BackOffExecution.nextBackOff() returns BackOffExecution.STOP.lastAccessTime before a session is considered
expired.maxlength' attribute.javax.jms.MessageListener objects or
javax.resource.cci.MessageListener implementation).method' attribute.org.quartz.CronTrigger class.org.quartz.SimpleTrigger class.ModelAndViewResolvers.ObjectMapper.ObjectMapper.multiple' attribute rendered
on the final 'select' element.name' attribute.name' attribute.NameCoder to use.NamedQueries instance.NamedQueries instance to be handed to the QueryLookupStrategy for query creation.Comparison.Detail#getXPath.ObjectNamingStrategy interface
to use for this exporter.xsi:noNamespaceSchemaLocation attribute.DataSource to be used for non-transactional access.NotificationFilter associated
with the encapsulated NotificationFilter.NotificationListener.NotificationListeners to register
with the MBeanServer.NotificationListenerBeans
containing the
NotificationListeners
that will be registered with the MBeanServer.NotificationPublisher instance for the current managed resource instance.RedisConnection.stringCommands()}.value for key, only if key does not exist.value for key, only if key does not exist.ObjectFactory to be used during unmarshalling.ObjectMapper for this view.ObjectMapper for this view.ObjectMapper for this view.ObjectMapper instance to use.ObjectMapper for this view.ObjectMapper for this view.ObjectMapper for this view.ObjectName of the MBean which calls are routed to,
as ObjectName instance or as String.ObjectName used to register the JMXConnectorServer
itself with the MBeanServer, as ObjectName instance
or as String.Class instances
mapped to comma separated field names.onblur' attribute.onchange' attribute.onclick' attribute.ondblclick' attribute.onfocus' attribute.onkeydown' attribute.onkeypress' attribute.onkeyup' attribute.onmousedown' attribute.onmousemove' attribute.onmouseout' attribute.onmouseover' attribute.onmouseup' attribute.onreset' attribute.onselect' attribute.onselect' attribute.onsubmit' attribute.HandlerMappings
configured in the Spring MVC application context.HandlerMapping used to map view
controllers relative to other handler mappings configured in Spring MVC.Origin header.MockHttpServletResponse.getOutputStream() access is allowed.ContentNegotiationManagerFactoryBean.setFavorParameter(boolean) is on.DefaultUriBuilderFactory.uriString(String) or one of the expand methods.RedisStandaloneConfiguration,
RedisSentinelConfiguration or RedisClusterConfiguration.RedisStandaloneConfiguration,
RedisSentinelConfiguration or RedisClusterConfiguration.form object.MappedInterceptor.matches(String, org.springframework.util.PathMatcher) method.PathMatcher to use when comparing target lookup path
against resource mappings.JedisPoolConfig using JedisClientConfiguration.RedisStandaloneConfiguration.RedisStandaloneConfiguration.TemplateLoaders that will be used to search
for templates.Pragma header.org.apache.tiles.preparer.factory.PreparerFactory implementation to use.CommonsMultipartFile.getOriginalFilename().CommonsMultipartFile.getOriginalFilename().TemplateLoaders that will be used to search
for templates.DefaultPrettyPrinter when writing JSON.GsonBuilder#setPrettyPrinting() when writing
JSON.true the query string of the current URL is appended
and thus propagated through to the redirected URL.MockPropertySource for this environment.Properties object.PropertyNamingStrategy to
configure the ObjectMapper with.Proxy to use for this request factory.QueryLookupStrategy.Key to be used.RedisConnection.stringCommands()}.ReactiveRedisConnection.KeyCommand.key starting at the specified offset with given
ReactiveStringCommands.SetRangeCommand.value.key starting at the specified offset with given value.key starting at the specified offset with given value.Range header.readonly' attribute.PatternMatchUtils.simpleMatch(java.lang.String, java.lang.String))
to use in order to recognize custom redirect prefixes in addition to "redirect:".PatternMatchUtils.simpleMatch(java.lang.String, java.lang.String)) to use in order to recognize
custom redirect prefixes in addition to "redirect:".ReflectionProvider to use.MBeanServer with the
MBeanServerFactory, making it available through
MBeanServerFactory.findMBeanServer().ObjectName that already exists.RelativeRedirectFilter, and also using the same response wrapper
as that filter does, or if both are configured, only one will wrap.ScheduledThreadPoolExecutor (JDK 7+).ScheduledThreadPoolExecutor (JDK 7+).UrlPathHelper.UrlPathHelper.Renderer to use.Renderer to use.ScriptTemplateConfigurer.setRenderFunction(String) documentation.ScriptTemplateConfigurer.setRenderObject(String) documentation.RequestBodyAdvice instances to intercept the
request before it is read and converted for @RequestBody and
HttpEntity method arguments.ResourceHttpMessageConverter to use.ScriptTemplateConfigurer.setResourceLoaderPath(String) documentation.Resources to be used to initialize the repositories.ResourceRegionHttpMessageConverter to use.ResourceResolvers to use.Resources to be used to load objects from and initialize the repositories eventually.Resources to be used to initialize the repositories.ResourceTransformers to use.ResourceUrlProvider to use when resolving the public
URL of links in a transformed resource (e.g. import links in a CSS file).@ResponseBody or returning ResponseEntity
but before the body is written to the response with the selected
HttpMessageConverter.ResponseBodyAdvice instances to intercept the
response before @ResponseBody or ResponseEntity return
values are written to the response body.content type unless the
View.SELECTED_CONTENT_TYPE request attribute is present and set
to a concrete media type.RestTemplate for the gateway.doRollback should be performed on failure of the
doCommit call.RollbackRuleAttribute objects
(and/or NoRollbackRuleAttribute objects) to apply.RowMapper instance to use for this query.rows' attribute.ReactiveZSetCommands.ZInterStoreCommand given a List of keys.ReactiveZSetCommands.ZUnionStoreCommand given a List of keys.ScheduledExecutorService to delegate to.TaskScheduler that will invoke
the scheduled methods, or a ScheduledExecutorService
to be wrapped as a TaskScheduler.TaskScheduler to register scheduled tasks with, or a
ScheduledExecutorService to be wrapped as a
TaskScheduler.Scheduler instance to operate on.SchedulerFactory instance to use.SchedulerFactory implementation to use.Scheduler to operate on via its scheduler name in the Spring
application context or also in the Quartz org.quartz.impl.SchedulerRepository.Validator.setSchemaSource(javax.xml.transform.Source).xsi:schemaLocation attribute.ScopeMetadataResolver for use with AnnotatedBeanDefinitionReader
and/or ClassPathBeanDefinitionScanner.ScriptTemplateConfigurer.setScripts(String...) documentation.secure flag indicating whether the mock request
was made using a secure channel, such as HTTPS./' as the separator
in the view name.GsonBuilder#serializeNulls() option when writing
JSON.RestClientException subclass.MBeanServerConnection used to connect to the
MBean which all invocations are routed to.MBeanServerConnection used to connect to the
MBean which all invocations are routed to.MBeanServer instance with which all beans should
be registered.MBeanServer.MBeanServer.JMXConnectorServer.MBeanServer.ServletConfig that this object runs in.ServletContext that this object runs in.ServletContext, e.g. for resource handling,
looking up file extensions, etc.defaultServletName property has not been explicitly set,
attempts to locate the default Servlet using the known common
container-specific names.TaglibFactory for the given ServletContext.action' attribute through a value
that is to be appended to the current servlet path.Session, possibly pulled from JNDI.WebSessionManager to use for managing web
sessions.JedisShardInfo using
JedisClientConfiguration.false, use thread-local ScriptEngine instances instead
of one single shared instance.ScriptTemplateConfigurer.setSharedEngine(Boolean) documentation.LettuceConnections to share a single native connection.LettuceClientConfiguration.SimpleDateFormat.ViewResolver that always returns the provided
view instance.size' attribute.size' attribute rendered
on the final 'select' element.LettuceClientConfiguration.ModelAndView used for view rendering purposes.RestClientException subclass.VersionStrategy as values.setBlob /
setClob method with a stream argument.HierarchicalStreamDriver to be used for readers and writers.HttpHeaders.getAcceptLanguageAsLocales().ServletRequest.getLocales().MediaType objects supported by this converter.MediaType objects supported by this converter.xsi:type attribute.tabindex' attribute.ListenableFuture whose value can be set via SettableListenableFuture.set(Object)
or SettableListenableFuture.setException(Throwable).target' attribute.Filter.init and
Filter.destroy lifecycle methods on the target bean.TaskDecorator to be applied to any Runnable
about to be executed.TaskDecorator to be applied to any Runnable
about to be executed.TaskDecorator to be applied to any Runnable
about to be executed.TaskDecorator to be applied to any Runnable
about to be executed.Executor to use as Quartz backend.WebAsyncManager.startCallableProcessing(Callable, Object...).AsyncTaskExecutor to use when a controller method
returns a Callable.AsyncTaskExecutor to use when a controller method
return a Callable.TaskScheduler to register scheduled tasks with.InheritableThreadLocal).InheritableThreadLocal).JMXConnectorServer should be started in a separate thread.JedisClientConfiguration.LettuceClientConfiguration.LocalTime objects.LocalTime objects.TimeUnit.SECONDS.TimeUnit.SECONDS.TimeZone to normalize the date values into, if any.TimeZone to normalize the date values into, if any.TimeZone to use for formatting.HttpSession,
holding the current TimeZone value.title' attribute.Topics into low-level channels and patterns.SQLExceptionTranslator references where the key must
be the database name as defined in the sql-error-codes.xml file.Trigger interface).TriggerTask objects.java.sql.Types class.Unmarshaller to be used.Unmarshaller to be used by this message converter.Unmarshaller.Listener to be registered with the JAXB Unmarshaller.Unmarshaller properties.Upgrade header.RestTemplate.UrlPathHelper.UrlPathHelper.UrlPathHelper.UrlPathHelper.UrlPathHelper to use in PathExtensionContentNegotiationStrategy.getMediaTypeKey(org.springframework.web.context.request.NativeWebRequest)
in order to derive the lookup path for a target request URL path.UrlPathHelper used to map requests to
static resources.UrlPathHelper used to map requests to
static resources.UrlPathHelper to use in
ResourceUrlProvider.getForRequestUrl(javax.servlet.http.HttpServletRequest, String)
in order to derive the lookup path for a target request URL path.UrlPathHelper to use for
the resolution of lookup paths.WebContentGenerator.setCacheControl(org.springframework.http.CacheControl)ContentNegotiationManagerFactoryBean.setUseRegisteredExtensionsOnly(boolean), which
has reverse behavior.AbstractMappingContentNegotiationStrategy.setUseRegisteredExtensionsOnly(boolean).406 Not Acceptable
status code should be returned if no suitable view can be found.JedisClientConfiguration.MediaTypeFactory.favorPathExtension or
ContentNegotiationManagerFactoryBean.setFavorParameter(boolean) is set, this property determines
whether to use only registered MediaType mappings or to allow
dynamic resolution, e.g. via MediaTypeFactory.configure content
negotiation.ContentNegotiationManager.setServletConfig, if available.JedisClientConfiguration.LettuceClientConfiguration.xsi:type attribute for the root element.LettuceConnectionFactory.getConnection().ValidationProviderResolver for bootstrapping the
provider of choice, as an alternative to META-INF driven resolution.Validator instead of the one created by default.value' attribute.value' attribute.<option> tag.AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int)
and sets this instance's exhaustion flag accordingly.LettuceClientConfiguration.ViewResolver.ViewResolvers.WebConnection to be used with the WebClient.Unmarshaller should preserve "ignorable" whitespace.setBlob /
setClob method with a Blob / Clob argument.Accept-Charset should be written to any outgoing request.Accept-Charset should be written to any outgoing request.MockHttpServletResponse.getWriter() access is allowed.Resource.UnsupportedOperationException.ShadowingClassLoader.DEFAULT_EXCLUDED_PACKAGES.Filter that generates an ETag value based on the
content on the response.MockMvcConfigurer that stores and re-uses the HTTP session across
multiple requests performed through the same MockMvc instance.HandlerMethod and then delegates to the
base class implementation of #shouldApplyTo(HttpServletRequest, Object)
passing the bean of the HandlerMethod.doCommit on a transaction that has been
marked as rollback-only in a global fashion.PropertyPath referenced should be matched ignoring case.AbstractRequestLoggingFilter.beforeRequest(javax.servlet.http.HttpServletRequest, java.lang.String)/AbstractRequestLoggingFilter.afterRequest(javax.servlet.http.HttpServletRequest, java.lang.String)
methods for the current request, i.e. whether logging is currently active
(and the log message is worth building).true to avoid filtering of the given request.javax.servlet.DispatcherType.ASYNC introduced
in Servlet 3.0 means a filter can be invoked in more than one thread
over the course of a single request.false so that the filter may delay the generation
of an ETag until the last asynchronously dispatched thread.web.xml.true).true) or rather after
transaction completion (false).RedisConnection.serverCommands().RedisConnection.serverCommands().RedisConnection.serverCommands().DataSource.Scheduler and call dispose on them.javax.resource.spi.BootstrapContext
interface, used for bootstrapping a JCA ResourceAdapter in a local environment.ClientHttpRequestFactory implementation that uses standard JDK facilities.ConnectionHandle interface,
containing a given JDBC Connection.SimpleControllerHandlerAdapter for processing requests
with interface-based controllers.Controller workflow interface with
the generic DispatcherServlet.SimpleDateFormat.DataSource interface,
configuring a plain old JDBC Driver via bean properties, and
returning a new Connection from every getConnection call.EvaluationContext that focuses on a subset
of essential SpEL features and customization options, targeting simple
condition evaluation and in particular data binding scenarios.SimpleEvaluationContext.HttpInvokerRequestExecutor implementation
that uses standard Java facilities to execute POST requests, without support for HTTP
authentication or advanced configuration options.FactoryBean that creates a simple
HTTP server, based on the HTTP server that is included in Sun's JRE 1.6.WebService annotation) and exporting
them through the HTTP server included in Sun's JDK 1.6.IdGenerator that starts at 1 and increments by 1 with each call.PathBasedRedisIndexDefinition for including property values in a secondary index.SimpleIndexDefinition.SimpleIndexDefinition.IndexedData implementation indicating storage of data within a Redis Set.SimpleIndexedPropertyValue.ClassLoader.WebService annotation) and exporting
them with a configured base address (by default "http://localhost:8080/")
using the JAX-WS provider's built-in publication support.SimpleJdbcCall.SimpleJdbcInsert.BeanFactory interface.LoadTimeWeaver that builds and exposes a
SimpleInstrumentableClassLoader.SimpleLoadTimeWeaver for the current context
ClassLoader.SimpleLoadTimeWeaver for the given
ClassLoader.SimpleMailMessage.SimpleMailMessage from the state
of an existing SimpleMailMessage instance.HandlerExceptionResolver implementation
that allows for mapping exception class names to view names, either for a set of
given handlers or for all handlers in the DispatcherServlet.javax.xml.namespace.NamespaceContext implementation.AbstractReflectiveMBeanInfoAssembler
that always votes yes for method and property inclusion, effectively exposing
all public methods and properties as operations and attributes.FactoryBean for remote SLSB proxies.RequestExpectationManager that matches requests to expectations
sequentially, i.e. in the order of declaration of expectations.org.xml.sax.ErrorHandler implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the Servlet interface.SessionStatus interface,
keeping the complete flag as an instance variable.org.apache.tiles.preparer.PreparerFactory implementation
that expects preparer class names and builds preparer instances for those,
creating them through the Spring ApplicationContext in order to apply
Spring container callbacks and configured Spring BeanPostProcessors.javax.resource.spi.work.WorkManager implementation that
delegates to a Spring TaskExecutor.Theme implementation, wrapping a name and an
underlying MessageSource.TaskExecutor interface
and listens to Spring lifecycle callbacks.TransactionFactory strategy interface,
simply wrapping a standard JTA TransactionManager.Scope implementation, delegating to
TransactionSynchronizationManager's resource binding mechanism.TransactionStatus
implementation.SimpleTransactionStatus class,
indicating a new transaction.SimpleTransactionStatus class.javax.xml.transform.ErrorListener implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.TriggerContext interface.null.FactoryBean for creating a Quartz org.quartz.SimpleTrigger
instance, supporting bean-style usage for trigger configuration.HandlerMapping
interface to map from URLs to request handler beans.Disposable instance that is initially not disposed but
can be by calling Disposable.dispose().Flux source or signal
NoSuchElementException for an empty source, or
IndexOutOfBoundsException for a source with more than one element.Flux source and emit a default
value for an empty source, but signal an IndexOutOfBoundsException for a
source with more than one element.Mono source or signal
NoSuchElementException for an empty source.Scheduler that hosts a single-threaded ExecutorService-based worker and is
suited for parallel work.Scheduler.Worker from some other
Scheduler and provides Scheduler.Worker
services on top of it.RowMapper implementation that converts a single column into a single
result value per row.SingleColumnRowMapper for bean-style configuration.SingleColumnRowMapper.SmartDataSource that wraps a single JDBC Connection
which is not closed after use.getConnection calls, and ignores calls to
Connection.close().SingleDataSourceLookup class.Flux source, and accept an empty
source but signal an IndexOutOfBoundsException for a source with more than
one element.ReactiveSetCommands.SRandMembersCommand to retrieve one random member.FluxSink that safely gates multi-threaded producer
Subscriber.onNext(Object).FluxSink that safely gates multi-threaded producer
Subscriber.onNext(Object).RedisConnection.setCommands()}.ReactiveSetCommands.SInterCommand.getKeys().keys.keys.RedisConnection.setCommands()}.keys and store result in destKey.keys and store result in destKey.RedisConnection.setCommands()}.ReactiveRedisConnection.KeyCommand.getKey() contains ReactiveRedisConnection.KeyCommand.getKey().key contains value.key contains value.key.key.key.key.key.key.key.key.key.key.FastByteArrayOutputStream.Flux then
emit the remaining elements.Flux emitted within the specified initial duration.Flux sequence.Flux until a specified Publisher signals
an onNext or onComplete.RedisConnection.serverCommands().RedisConnection.serverCommands().application context
for an integration test managed by the Spring TestContext Framework.javax.sql.DataSource interface, to be
implemented by special DataSources that return JDBC Connections
in an unwrapped fashion.RequestBuilder that applies its
RequestPostProcessors
as a separate step from the RequestBuilder.buildRequest(javax.servlet.ServletContext) method.Validator interface, adding support for
validation 'hints'.RedisConnection.setCommands()}.ReactiveRedisConnection.KeyCommand.getKey().key.key.Jackson2ObjectMapperBuilder instance in order to
build a Smile data format ObjectMapper instance.RedisConnection.setCommands()}.value from srcKey to destKeyvalue from srcKey to destKeylocalhost.SocketUtils consists solely of static utility methods,
this constructor is intentionally public.RedisConnection.keyCommands().RedisConnection.keyCommands().Sort.Direction.Sort.Direction.key.key and store result in storeKey.key.key and store result in storeKey.query.query applying RedisSerializer.query applying BulkMapper.query and store result in storeKey.Flux by collecting and sorting them in the background
then emitting the sorted sequence once this sequence completes.Flux using a Comparator function, by
collecting and sorting elements in the background then emitting the sorted sequence
once this sequence completes.Sort object from a NativeWebRequest for a particular
MethodParameter.MediaType objects by quality value.MediaType objects by specificity.MimeType objects by specificity.MediaType objects by specificity as the
primary criteria and quality value the secondary.Sort options to be used when injecting a Sort instance into a
controller handler method.SortDefault annotations on a method parameter.ParallelFlux and returns a Publisher that
sequentially picks the smallest next value from the rails.ParallelFlux and returns a Publisher that
sequentially picks the smallest next value from the rails.FactoryBean implementation that takes a list of location Strings
and creates a sorted array of Resource instances.HandlerMethodArgumentResolver to automatically create Sort instances from request parameters or
SortDefault annotations.SortHandlerMethodArgumentResolver configuration.SortParameters).SortQuery.String array into sorted array.DOMSource and apply the given Matcher.DOMSource and apply the given
Hamcrest Matcher.HttpMessageConverter
that can read and write Source objects.span' tag.ClassTypeInformation using the context of the current potentially parameterized
type, basically turning the given raw type into a parameterized one.MediaType.sortBySpecificity(List).MimeTypeUtils.sortBySpecificity(List).SpelExpression represents a parsed (valid) expression that is ready to be
evaluated in a specified context.SpelIndexDefinition defines index that is evaluated based on a SpelExpression requires the
SpelIndexResolver to be evaluated.SpelIndexDefinition.SpelExpressionParser.SpelParserConfiguration instance with default settings.SpelParserConfiguration instance.SpelParserConfiguration instance.SpelParserConfiguration instance.SpelParserConfiguration instance.source into partitioned arrays using delimiter c.String at the first occurrence of the delimiter.String.String and returns the parts in lower case.RedisConnection.setCommands()}.RedisConnection.setCommands()}.count random members from set at key.ReactiveRedisConnection.KeyCommand.getKey()key.count random members from set at key.key.count random members from set at key.ELResolver that delegates to the Spring root WebApplicationContext,
resolving name references to Spring-defined beans.AdaptableJobFactory that also supports Spring-style
dependency injection on bean properties.org.apache.tiles.preparer.PreparerFactory implementation
that expects preparer bean names and obtains preparer beans from the
Spring ApplicationContext.SpringClassRule is a custom JUnit TestRule that supports
class-level features of the Spring TestContext Framework
in standard JUnit tests by means of the TestContextManager and
associated support classes and annotations.ConstraintValidatorFactory implementation that delegates to a
Spring BeanFactory for creating autowired ConstraintValidator instances.javax.resource.spi.ResourceAdapter implementation
that loads a Spring ApplicationContext,
starting and stopping Spring-managed beans as part of the ResourceAdapter's
lifecycle.AnnotationBeanNameGenerator to work without a BeanDefinitionRegistry.ObjectMapper configured for EnableSpringDataWebSupport.PageableHandlerMethodArgumentResolver,
SortHandlerMethodArgumentResolver and DomainClassConverter.SpringExtension integrates the Spring TestContext Framework
into JUnit 5's Jupiter programming model.SpringFailOnTimeout is a custom JUnit Statement which adds
support for Spring's @Timed
annotation by throwing an exception if the next statement in the execution
chain takes more than the specified number of milliseconds.SpringFailOnTimeout statement for the supplied
testMethod, retrieving the configured timeout from the
@Timed annotation on the supplied method.SpringFailOnTimeout statement for the supplied
timeout.JsonSerializer, JsonDeserializer,
KeyDeserializer, TypeResolverBuilder, TypeIdResolver)
beans with autowiring against a Spring ApplicationContext.Synchronization
interface delegating to an underlying Spring
TransactionSynchronization.SpringJUnit4ClassRunner is a custom extension of JUnit's
BlockJUnit4ClassRunner which provides functionality of the
Spring TestContext Framework to standard JUnit tests by means of the
TestContextManager and associated support classes and annotations.SpringJUnit4ClassRunner and initialize a
TestContextManager to provide Spring testing functionality to
standard JUnit tests.@SpringJUnitConfig is a composed annotation that combines
@ExtendWith(SpringExtension.class) from JUnit Jupiter with
@ContextConfiguration from the Spring TestContext
Framework.@SpringJUnitWebConfig is a composed annotation that combines
@ExtendWith(SpringExtension.class) from JUnit Jupiter with
@ContextConfiguration and
@WebAppConfiguration from the Spring TestContext
Framework.LocaleResolver, exposing the
DispatcherServlet-managed locale.SpringMethodRule is a custom JUnit 4 MethodRule that
supports instance-level and method-level features of the
Spring TestContext Framework in standard JUnit tests by means
of the TestContextManager and associated support classes and
annotations.RequiredModelMBean class that ensures the
thread context ClassLoader is switched
for the managed resource's ClassLoader before any invocations occur.ModelMBeanInfo.ModelMBeanInfo.ObjenesisStd / ObjenesisBase,
providing a cache based on Class keys instead of class names,
and allowing for selective use of the cache.SpringObjenesis instance with the
standard instantiator strategy.SpringObjenesis instance with the
given standard instantiator strategy.SpringRepeat is a custom JUnit Statement which adds support
for Spring's @Repeat
annotation by repeating the test the specified number of times.SpringRepeat statement for the supplied
testMethod, retrieving the configured repeat count from the
@Repeat annotation on the supplied method.SpringRepeat statement for the supplied
testMethod and repeat count.SpringRunner is an alias for the SpringJUnit4ClassRunner.SpringRunner and initialize a
TestContextManager
to provide Spring testing functionality to standard JUnit 4 tests.ServletContainerInitializer designed to support code-based
configuration of the servlet container using Spring's WebApplicationInitializer
SPI as opposed to (or possibly in combination with) the traditional
web.xml-based approach.TemplateLoader adapter that loads via a Spring ResourceLoader.TestContextManager to call
'after test class' callbacks.TestContextManager to
post-process the test method after the actual test has executed.TestContextManager to call
'before test class' callbacks.TestContextManager to
pre-process
the test method before the actual test is executed.TestContextManager to
prepare this test
instance prior to execution of any individual tests, for example for
injecting dependencies, etc.Transactional annotation.javax.validator.Validator and
exposes it as a Spring Validator
while also exposing the original JSR-303 Validator interface itself.ConstraintValidatorFactory implementation that delegates to
the current Spring WebApplicationContext for creating autowired
ConstraintValidator instances.@Sql is used to annotate a test class or test method to configure
SQL Sql.scripts() and Sql.statements() to be executed against a given
database during integration tests.@SqlConfig defines metadata that is used to determine how to parse
and execute SQL scripts configured via the @Sql annotation.SQLErrorCodes based on the
"databaseProductName" taken from the DatabaseMetaData.SQLErrorCodesFactory class.SQLExceptionTranslator that analyzes vendor-specific error codes.SQLExceptionTranslator implementation which analyzes the specific
SQLException subclass thrown by the JDBC driver.SQLExceptions
and Spring's data access strategy-agnostic DataAccessException
hierarchy.@Sql annotations.SqlOutParameter to represent an INOUT parameter.SqlParameter to represent an output parameter.NamedParameterJdbcTemplate operations.SqlParameterSource,
in particular with NamedParameterJdbcTemplate.DataSource and SQL string.ResultSet from a stored procedure call.SqlReturnResultSet class.SqlReturnResultSet class.SqlReturnResultSet class.CallableStatement.getObject method.SqlRowSet, analogous to JDBC's
ResultSetMetaData.ResultSetExtractor implementation that returns a Spring SqlRowSet
representation for each given ResultSet.TestExecutionListener that provides support for executing SQL
scripts and inlined statements
configured via the @Sql annotation.CallMetaDataProvider interface.DataFieldMaxValueIncrementer that increments the maximum value of a given SQL Server table
with the equivalent of an auto-increment column.SQLExceptionTranslator implementation that analyzes the SQL state in
the SQLException based on the first two digits (the SQL state "class").java.sql.Types,
to a List of SqlParameter objects as used in this package.setObject method.SQLWarnings.SqlValue
that supports passing in XML data to specified column and adds a
cleanup callback, to be invoked after the value has been set and
the corresponding statement has been executed.RedisConnection.setCommands()}.RedisConnection.setCommands()}.ReactiveSetCommands.SRandMembersCommand.getCount() random elements from set at ReactiveRedisConnection.KeyCommand.getKey().key.count random elements from set at key.key.count random elements from set at key.RedisConnection.setCommands()}.ReactiveSetCommands.SRemCommand.getValues() from set at ReactiveRedisConnection.KeyCommand.getKey().values from set at key and return the number of removed elements.values from set at key and return the number of removed elements.RedisConnection.setCommands()}.Cursor to iterate over elements in set at key.Cursor to iterate over elements in set at key.ResponseBodyEmitter for sending
Server-Sent Events.MockMvcBuilder that accepts @Controller registrations
thus allowing full control over the instantiation and initialization of
controllers and their dependencies similar to plain unit tests, and also
making it possible to test one controller at a time.MockMvc instance by registering one or more
@Controller instances and configuring Spring MVC infrastructure
programmatically.EvaluationContext implementation.StandardEvaluationContext with a null root object.StandardEvaluationContext with the given root object.ScriptException coming out of
JSR-223 script evaluation, i.e. a ScriptEngine.eval(java.lang.String, javax.script.ScriptContext)
call or Invocable.invokeMethod(java.lang.Object, java.lang.String, java.lang.Object...) /
Invocable.invokeFunction(java.lang.String, java.lang.Object...) call.javax.script (JSR-223) based implementation of Spring's ScriptEvaluator
strategy interface.StandardScriptEvaluator.StandardScriptEvaluator for the given class loader.StandardScriptEvaluator for the given JSR-223
ScriptEngineManager to obtain script engines from.ScriptFactory implementation based
on the JSR-223 script engine abstraction (as included in Java 6+).ScriptEngine.AsyncWebRequest.Environment implementation to be used by Servlet-based web
applications.MultipartResolver interface,
based on the Servlet 3.0 Part API.TypeComparator implementation.TypeConverter interface,
delegating to a core Spring ConversionService.TypeLocator that uses the context ClassLoader
(or any ClassLoader set upon it).ServerHttpAsyncRequestControl.complete() is made or the server times out the request.ServerHttpAsyncRequestControl.start() that allows specifying a timeout value to use to
use for asynchronous processing.SpringContextResourceAdapter.createApplicationContext(BootstrapContext) template method.WebSession.save() is called.AsyncTaskExecutor.WebAsyncTask to configure the task executor as well as
the timeout value of the AsyncWebRequest before delegating to
WebAsyncManager.startCallableProcessing(Callable, Object...).DeferredResult with a DeferredResult.DeferredResultHandler that saves
the result and dispatches the request to resume processing of that
result.haystack starts with the given prefix.haystack beginning at the specified offset starts with the given prefix.String starts with the specified prefix,
ignoring upper/lower case.Flux sequence.Publisher sequence to this Flux sequence.IllegalStateException
if the expression evaluates to false.IllegalStateException
if the expression evaluates to false.Assert.state(boolean, String)ScriptSource interface,
encapsulating a given String that contains the script source text.WebApplicationContext
implementation for testing.BackOffExecution.nextBackOff() that indicates that the operation
should not be retried.ContextIterables.OutputStream.OutputStream
without holding up the Servlet container thread.StreamingResponseBody
and also ResponseEntity<StreamingResponseBody>.Stream utility methods and classes.RedisSerializationContext.SerializationPair.RedisElementReader and RedisElementWriter.RedisSerializationContext.SerializationPair given a RedisSerializer.RedisSerializationContext using a StringRedisSerializer.Matcher.Matcher.Matcher.String value found with the given
Hamcrest Matcher.String value found.RedisStringCommands.HttpMessageConverter that can read and write strings."ISO-8859-1" as the default charset.PropertyEditor for converting
MultipartFiles to Strings.StringMultipartFileEditor, using the default charset.StringMultipartFileEditor, using the given charset.RedisConnection that accepts and returns Strings instead of byte arrays.StringRedisSerializer using UTF-8.StringRedisSerializer using the given Charset to encode and decode strings.StringRedisTemplate instance.StringRedisTemplate instance ready to be used.ReactiveZSetCommands.ZRangeByLexCommand given a Range of String to retrieve elements
lexicographical ordering.DataTypesPropertiesString utility methods.Matcher.RedisConnection.stringCommands()}.key.key.RepositoryFragment given interfaceOrImplementation.Flux and request unbounded demand.Publisher.subscribe(Subscriber) that will bypass
Hooks.onLastOperator(Function) pointcut.Mono and request unbounded demand.Publisher.subscribe(Subscriber) that will bypass
Hooks.onLastOperator(Function) pointcut.ParallelFlux and triggers the
execution chain for all 'rails'.ParallelFlux and triggers the execution chain for all
'rails'.ParallelFlux by providing an onNext callback and
triggers the execution chain for all 'rails'.ParallelFlux by providing an onNext and onError callback
and triggers the execution chain for all 'rails'.ParallelFlux by providing an onNext, onError and
onComplete callback and triggers the execution chain for all 'rails'.ParallelFlux by providing an onNext, onError,
onComplete and onSubscribe callback and triggers the execution chain for all
'rails'.ParallelFlux.sequential() Flux and
subscribe to said Flux.Signal of variety Type.ON_SUBSCRIBE.Signal of variety Type.ON_SUBSCRIBE, that
holds the Context associated with the subscribed source.Scheduler's Scheduler.Worker.Scheduler's Scheduler.Worker.Scheduler's Scheduler.Worker.pNameSuccessCallback.onSuccess(Object) call on all
added callbacks with the given result.ListenableFuture.RedisConnection.setCommands()}.ReactiveSetCommands.SInterCommand.getKeys().keys.keys.RedisConnection.setCommands()}.keys and store result in destKey.keys and store result in destKey.repositoryInterface is supported by this interceptor.argumentTypes.type is a supported reactive wrapper type.true for all classes, i.e.HandlerAdapter
can support it.HandlerMethod.HttpMessageConverter type.true since any method argument and return value
type will be processed in some way.Parameter in the supplied ParameterContext
should be autowired from the test's ApplicationContext.WebArgumentResolver.UNRESOLVED absorbing _any_ exceptions.true if the parameter is annotated with
ModelAttribute or, if in default resolution mode, for any
method parameter that is not a simple type.HandlerMethodArgumentResolver.@RequestPart
of type MultipartFile unless annotated with @RequestParam
of type javax.servlet.http.Part unless annotated with @RequestParam
true since WebSphere ResourceAdapters (as exposed in JNDI)
implicitly perform transaction enlistment if the MessageEndpointFactory's
isDeliveryTransacted method returns true.true if there is a method-level @ModelAttribute
or, in default resolution mode, for any return value type that is not
a simple type.HandlerMethodReturnValueHandler.true.MethodInterceptor detecting whether a transaction is already running and exposing that fact via
SurroundingTransactionDetectorMethodInterceptor.isSurroundingTransactionActive().Disposable.Swap with atomic guarantees on all mutative
operations.Publisher if this sequence is completed without any data.Mono if this mono is completed without data
Flux that mirrors the most recently emitted Publisher,
forwarding its data until a new Publisher comes in in the source.Flux that mirrors the most recently emitted Publisher,
forwarding its data until a new Publisher comes in in the source.FluxProcessor whose data are emitted by the most recent emitted Publisher.LettuceConnection.close() the current connection and open a new pub/sub connection to the Redis server.DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column.CallMetaDataProvider interface.DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column.Object and
perform the request.HttpMessageReader for parsing "multipart/form-data" requests
to a stream of Part's using the Synchronoss NIO Multipart library.Subscriber.AnnotationAttributes
in this descriptor back into an annotation of the target
annotation type.UnsupportedOperationException since the type of annotation
represented by the AnnotationAttributes in
an UntypedAnnotationDescriptor is unknown.ProfileValueSource which uses system properties as
the underlying source.TableMetaDataProvider implementation
based on the type of database being used.Scannable and its Scannable.parents() and stream all the
observed tagsStrings to web scopes.Writer instance.TagWriter class that writes to
the supplied PageContext.Flux, if available.Flux emitted before its completion.Flux until the given Publisher emits.Publisher emits.Flux while a predicate returns TRUE
for the values (checked before each value is delivered).Runnable to be executed as a task, typically at a
scheduled time or interval.Task.FactoryBean for creating ThreadPoolTaskExecutor instances,
primarily used behind the XML task namespace.NamespaceHandler for the 'task' namespace.Runnables based on different kinds of triggers.TE header field name.java.io.File.ParserContext implementation for template parsing.Parser implementation for a JSR-310 TemporalAccessor,
using a DateTimeFormatter) (the contextual one, if available).Printer implementation for a JSR-310 TemporalAccessor,
using a DateTimeFormatter) (the contextual one, if available).LobCreator implementation based on temporary LOBs,
using JDBC 4.0's Connection.createBlob() /
Connection.createClob() mechanism.Operators.cancelledSubscription(), cancelling the subscription and setting the field
to the singleton Operators.cancelledSubscription().Boolean attribute indicating whether or not an upstream component
terminated this scanned component. e.g. a post onComplete/onError subscriber.TestContext encapsulates the context in which a test is executed,
agnostic of the actual testing framework in use.TestContextBootstrapper defines the SPI for bootstrapping the
Spring TestContext Framework.TestContextManager is the main entry point into the Spring
TestContext Framework.TestContextManager for the supplied test class.TestContextManager using the supplied TestContextBootstrapper
and register the necessary
TestExecutionListeners.TestExecutionListener defines a listener API for reacting to
test execution events published by the TestContextManager with which
the listener is registered.TestExecutionListeners defines class-level metadata for configuring
which TestExecutionListeners should be
registered with a TestContextManager.@TestExecutionListeners is declared on a class that does
not inherit listeners from a superclass.@TestPropertySource is a class-level annotation that is used to
configure the TestPropertySource.locations() of properties files and inlined
TestPropertySource.properties() to be added to the Environment's set of
PropertySources for an
ApplicationContext
for integration tests.@TestPropertySource
and adding test PropertySources to the Environment.TestTransaction provides a collection of static utility methods for
programmatic interaction with test-managed transactions within
test methods, before methods, and after methods.text/event-stream.MediaType.TEXT_EVENT_STREAM.text/html.text/html.MediaType.TEXT_HTML.MimeTypeUtils.TEXT_HTML.text/markdown.MediaType.TEXT_MARKDOWN.text/plain.text/plain.MediaType.TEXT_PLAIN.MimeTypeUtils.TEXT_PLAIN.text/xml.text/xml.MediaType.TEXT_XML.MimeTypeUtils.TEXT_XML.<textarea> tag renders an HTML 'textarea'.Themes.<theme> tag looks up a theme message in the scope of this page.Mono<Void> that completes when this Flux completes.Mono<Void> which only replays complete and error signals
from this Mono.Mono complete then play another Mono.Mono<Void> that waits for this Flux to complete then
for a supplied Publisher<Void> to also complete.Mono<Void> that waits for this Mono to complete then
for a supplied Publisher<Void> to also complete.Flux complete then play another Publisher.Mono complete then play another Publisher.Mono complete then emit the provided value.ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds",
"queueCapacity" properties) and exposing it as a bean reference of its native
ExecutorService type.ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties) and exposing it as a Spring TaskExecutor.TaskScheduler interface, wrapping
a native ScheduledThreadPoolExecutor.Throwable only if it belongs to a push of "fatal" error
varieties.Throwable only if it belongs to a push of "fatal" error
varieties native to the JVM.View implementation that renders
through the Tiles Request API.UrlBasedViewResolver that supports
TilesView (i.e.RedisConnection.serverCommands().RedisConnection.serverCommands().TIME command.TIME command.TIME command.TimeoutException as soon as no item is emitted within the
given Duration from the previous emission (or the subscription for the first item).TimeoutException as soon as no item is emitted within the
given Duration from the previous emission (or the subscription for the first
item), as measured by the specified Scheduler.TimeoutException in case the first item from this Flux has
not been emitted before the given Publisher emits.TimeoutException in case the first item from this Flux has
not been emitted before the firstTimeout Publisher emits, and whenever
each subsequent elements is not emitted before a Publisher generated from
the latest element signals.Publisher in case the first item from this Flux has
not been emitted before the firstTimeout Publisher emits, and whenever
each subsequent elements is not emitted before a Publisher generated from
the latest element signals.TimeoutException in case no item arrives within the given
Duration.TimeoutException error in case an item doesn't arrive before the given period,
as measured on the provided Scheduler.TimeoutException in case the item from this Mono has
not been emitted before the given Publisher emits.Publisher in case the item from this Mono has
not been emitted before the given Publisher emits.commonj.timers.TimerManager
Defines common configuration settings and common lifecycle handling.FactoryBean that retrieves a
CommonJ commonj.timers.TimerManager and exposes it for bean references.TaskScheduler interface, wrapping
a CommonJ commonj.timers.TimerManager.TimeToLive marks a single numeric property on aggregate root to be used for setting expirations in Redis.TimeToLiveAccessor extracts the objects time to live used for EXPIRE.TimeZone to use for formatting.TimeZone to use for formatting.ConversionService.ConversionService.Collection into a Class array.CLUSTER NODES into a RedisClusterNode.Subscriber is not a CoreSubscriber, it will apply
safe strict wrapping to apply all reactive streams rules including the ones
relaxed by internal operators based on CoreSubscriber.DefaultMessageCodesResolver.CODE_SEPARATOR, skipping zero-length or
null elements altogether.null).PagedResources with an empt collection EmbeddedWrapper for the given domain type.PagedResources with an empt collection EmbeddedWrapper for the given domain type.Mono into a CompletableFuture completing on onNext or onComplete and failing on
onError.RedisGeoCommands.GeoRadiusCommandArgs into GeoArgs.Metric into GeoArgs.Unit.Point into GeoCoordinate.RedisGeoCommands.GeoRadiusCommandArgs into GeoRadiusParam.Metric into GeoUnit.object to a map that can be used with Redis hashes.Range.Locale.toLanguageTag()RedisZSetCommands.Limit to a lettuce
Limit.ServletHttpHandlerAdapter extension that uses Tomcat APIs for reading
from the request and writing to the response with ByteBuffer.LoadTimeWeaver implementation
for Tomcat's new org.apache.tomcat.InstrumentableClassLoader.TomcatLoadTimeWeaver class using
the default class loader.TomcatLoadTimeWeaver class using
the supplied ClassLoader.Collector to create a MultiValueMap.Map<K, List<V>> to an MultiValueMap<K, V>.DataRetrievalFailureException thrown when following cluster redirects exceeds the max number of edges.TooManyClusterRedirectionsException.TooManyClusterRedirectionsException.Optional containing the password value.TopicProcessor builder that can be used to create new
processors.Mono into a MonoProcessor (turning it hot and allowing to block,
cancel, as well as many other operations).CONFIG GET) from a List to
Properties.RedisZSetCommands.Range to a lettuce Range.PagedResources by converting the given Page into a PageMetadata instance and
wrapping the contained elements into Resource instances.PagedResources by converting the given Page into a PageMetadata instance and
using the given ResourceAssembler to turn elements of the Page into resources.PagedResources by converting the given Page into a PageMetadata instance and
using the given ResourceAssembler to turn elements of the Page into resources.Resource into a ResourceRegion using the range
information contained in the current HttpRange.HttpRange into a ResourceRegion, selecting the
appropriate segment of the given Resource using HTTP Range information.RedisZSetCommands.Range to a lettuce Range and
reverse boundaries.ScanOptions to Jedis ScanParams.Expiration to the according SET command argument.RedisStringCommands.SetOption to the according SET command argument.CLUSTER NODES into RedisClusterNodes.CLUSTER NODES into RedisClusterNodes.MultiValueMap.HttpRange objects.MediaType objects.ContextLoader, and the
parent configuration.ContextLoader, and the
parent configuration.AnnotationDescriptor.MimeType objects.getTaskInfo() and use the task info directly.toString().UriComponents.toUriString().ComparisonFormatterDefaultComparisonFormatterComparisonFormatterDefaultComparisonFormatterCollection into a String array.String array.seconds and microseconds.List containing the second array appended to the first one.List backed by the given array.URI from this instance as follows:
If the current instance is encoded, form the full
URI String via UriComponents.toUriString(), and then pass it to the single
argument URI constructor which preserves percent encoding.Trailer header field name.Configuration class.EventListener that is invoked according to a TransactionPhase.EventListenerFactory implementation that handles TransactionalEventListener
annotated method.RepositoryFactoryBeanSupport to add transactional capabilities to the repository proxy.TransactionalRepositoryFactoryBeanSupport for the given repository interface.TestExecutionListener that provides support for executing tests
within test-managed transactions by honoring Spring's
@Transactional
annotation.TransactionInterceptor
or an AspectJ aspect.rollbackOn specification to TransactionDefinition.TransactionAttribute objects.TransactionInterceptor for metadata retrieval.TransactionAttributeSource, used to include
a TransactionInterceptor only for methods that are transactional.TransactionAttributeSource.javax.resource.cci.ConnectionFactory, adding
awareness of Spring-managed transactions.DataSource, adding awareness of
Spring-managed transactions.Transaction
objects based on specified transactional characteristics.PlatformTransactionManager).AbstractTransactionManagementConfiguration
should be used based on the value of EnableTransactionManagement.mode() on the
importing @Configuration class.Configuration classes annotated with @EnableTransactionManagement that wish to
or need to explicitly specify the default PlatformTransactionManager bean to be
used for annotation-driven transaction management, as opposed to the default approach
of a by-type lookup.FutureResults.TransactionSynchronization adapter containing empty
method implementations, for easier overriding of single methods.TransactionSynchronization
callback methods on all currently registered synchronizations.Transfer-Encoding header field name.Source to the Result.Transformation.ParallelFlux
and returns another ParallelFlux with composed features.ByteArrayResource that a ResourceTransformer
can use to represent an original resource preserving all other information
except the content.Transformers
and the javax.xml.transform package in general.<transform> tag provides transformation for reference data values
from controllers and other objects inside a spring:bind tag (or a
data-bound form element tag from Spring's form tag library).Exception into DataAccessException.AbstractFallbackSQLExceptionTranslator.doTranslate(java.lang.String, java.lang.String, java.sql.SQLException), and invokes the
fallback translator if necessary.SQLException into a generic DataAccessException.SQLException into a generic DataAccessException.afterCommit callbacks on all currently registered synchronizations.afterCompletion callbacks on all currently registered synchronizations.beforeCommit callbacks.beforeCommit callbacks on all currently registered synchronizations.beforeCompletion callbacks.beforeCompletion callbacks on all currently registered synchronizations.flush callbacks on all currently registered synchronizations.TriggerTask.start and end.key to elements between start and end.key to elements between start and end.String:
leading, trailing, and in between characters.String array,
calling String.trim() on each of them.String.String.String.String.String.true higher than false.true lower than false.RedisConnection.keyCommands().RedisConnection.keyCommands().key in seconds.key in seconds.key in and convert it to the given TimeUnit.key in seconds.key in and convert it to the given TimeUnit.ReactiveZSetCommands.ZAddCommand given a RedisZSetCommands.Tuple.Collection of objects, each of which can be of an arbitrary type.TransactionManagementConfigurer.NamespaceHandler allowing for the configuration of
declarative transaction management using either XML or using annotations.RedisConnection.keyCommands().key.key.key.key.TypeDescriptor that describes it.TypedValue for a simple object.TypedValue for a particular value with a particular
TypeDescriptor which may contain additional generic declarations.UnableToRegisterMBeanException with the
specified error message.UnableToRegisterMBeanException with the
specified error message and root cause.Notification is unable to be sent.UnableToSendNotificationException
class with the specified error message.UnableToSendNotificationException
with the specified error message and root cause.String, changing the first letter to
lower case as per Character.toLowerCase(char).UncategorizedMappingException with the specified detail message
and nested exception.SQLException
from JDBC that we cannot pinpoint more precisely.UncategorizedScriptException.UncategorizedScriptException.HttpHandler to the Undertow io.undertow.server.HttpHandler.Escaper that converts literal text into a format safe for
inclusion in a particular context (such as an XML document).key and key.keys and keys.keys and otherKey.keys and otherKeys.keys and otherKey.keys and otherKeys.key and store result in destKey.keys and store result in destKey.otherKeys and store result in destination destKey.otherKeys and store result in destination destKey.key and otherKey and store result in destKey.key and otherKeys and store result in destKey.key and otherKeys and store result in destination destKey.key and otherKeys and store result in destination destKey.key and otherKey and store result in destKey.key and otherKeys and store result in destKey.key and otherKeys and store result in destination destKey.key and otherKeys and store result in destination destKey.HttpStatusCodeException based on an
HttpStatus, status text, and response body content.Source into an object graph,
reading binary attachments from a MimeContainer.javax.xml.transform.Source into an object graph.Source into an object graph.Node.DOMSources.InputStream.MarshallingFailureException with the specified detail message.MarshallingFailureException with the specified detail message
and nested exception.Reader.XMLReader
and InputSource.SAXSources.StaxSources.StreamSources.XMLEventReader.XMLStreamReader.RequestExpectationManager that matches requests to expectations
regardless of the order of declaration of expected requests.DataSource, if registered.RequestDispatcher with the given name.ServletRequestBindingException subclass that indicates an unsatisfied
parameter condition, as typically expressed using an @RequestMapping
annotation at the @Controller type level.#watch(byte[]...) keys.RedisOperations.watch(Object) keys.Exception
(typically PropertyAccessException)
or a Bean Validation ConstraintViolation.Optional.TypeInformation.updateRow() method for each row.update that adds the given statement
parameters to the queue rather than executing them immediately.Disposable on this container and dispose the previous
one (if any).session.setAttribute
calls, explicitly indicating to the container that they might have been modified.AbstractRequestExpectationManager.RequestExpectationGroup.addAllExpectations(Collection) instead.@SessionAttributes to the session.RequestDataValueProcessor, if any, and allow
it to update the redirect target URL.Upgrade header field name.Subscriptionpath is also set, it overrides the path
of the URI provided here.URI.UriBuilder obtained
through the UriBuilderFactory configured for this client.HttpServletRequest attribute that contains the URI
templates map, mapping variable names to values.UriBuilderFactory instance as an
alternative to and effectively overriding WebTestClient.Builder.baseUrl(String).UriBuilder instances with shared configuration
such as a base URI, an encoding mode strategy, and others across all URI
builder instances created through a factory.UriComponents instance.UriComponents.UriComponentsBuilder.UriComponents by
looking at a method parameter and an argument value and deciding what
part of the target URL should be updated.UriTemplate with the given URI String.CorsConfiguration instance based on a
collection of CorsConfiguration mapped on path patterns.UrlBasedCorsConfigurationSource instance with default
PathPatternParser.UrlBasedCorsConfigurationSource instance from the supplied
PathPatternParser.CorsConfiguration instance based on a
collection of CorsConfiguration mapped on path patterns.ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definition.UrlBasedViewResolver.Controller implementation that transforms the virtual
path of a URL into a view name and returns that view.WebRequestMatcher that allows matching on
WebRequest#getUrl().toExternalForm() using a regular expression.<url> tag creates URLs."useCaches" flag on the
given connection, preferring false but leaving the
flag at true for JNLP based resources.Loggers, even if SLF4J is available
on the classpath.include or
forward method.include or
forward method.ContentNegotiationConfigurer.useRegisteredExtensionsOnly(boolean)
which has reverse behaviorLoggers, even if SLF4J is available
on the classpath.WebRequestMatcher instances that will ensure
that MockMvc is used to process the request, if such a matcher
matches against the web request.WebRequestMatcher instances that return true
if a supplied host matches — for example, "example.com" or
"example.com:8080".XmlRootElement annotation and is not an instants of JAXBElement it
must be wrapped by a JAXBElement.User-Agent header field name.java.lang.Object.DataSource, applying the specified
user credentials to every standard getConnection() call, implicitly
invoking getConnection(username, password) on the target.favorPathExtension is set, this
property determines whether to use only registered MediaType mappings
to resolve a path extension to a specific MediaType.null to clear the user info of this builder.TransactionManager reference and creating
a JTA UserTransaction handle for it.Loggers, throwing an exception if
SLF4J isn't available on the classpath.com.sun.* classes, which is only available on a Sun/Oracle JVM.sun.misc
package.target object, which must be of a type of Class
for which the Validator.supports(Class) method typically returns true.target object, which must be
of a Class for which the Validator.supports(Class) method
typically has (or would) return true.Operators.reportBadRequest(long)Valid, supporting the
specification of validation groups.fragments have an implementation.MergedContextConfiguration with respect to
what this context loader supports.MergedContextConfiguration does not
contain locations.MergedContextConfiguration does not
contain classes.MergedContextConfiguration does not
contain classes.WebMergedContextConfiguration with respect to
what this context loader supports.WebMergedContextConfiguration does not
contain locations.WebMergedContextConfiguration does not
contain classes.AbstractRequestExpectationManager.matchRequest(ClientHttpRequest)
instead and return only the matched expectation, leaving the call to create the response
as a separate step (to be invoked by this class).HttpURLConnection object,
throwing an exception if it does not correspond to a successful HTTP response.ParsingValidator doesn't support validation of the
schema itself.ValidationFailureException with the specified detail message.ValidationFailureException with the specified detail message
and nested exception.Validator
and for rejecting empty fields.ReactiveHashCommands.HSetCommand given a key.ReactiveHyperLogLogCommands.PfAddCommand given a value.ReactiveListCommands.LInsertCommand given a value.ReactiveSetCommands.SAddCommand given a value.ReactiveSetCommands.SIsMemberCommand given a value.ReactiveSetCommands.SMoveCommand given a value.ReactiveSetCommands.SRemCommand given a value.RedisSerializationContext.SerializationPair.RedisElementReader and RedisElementWriter.RedisSerializationContext.SerializationPair given a RedisSerializer.Matcher.JsonPathRequestMatchers.value(Matcher) that also accepts a
target type for the resulting value that the matcher can work reliably
against.Matcher.Matcher.JsonPathResultMatchers.value(Matcher) that also accepts a
target type for the resulting value that the matcher can work reliably
against.ReactiveSetCommands.SRandMembersCommand given the number of values to retrieve.ReactiveHyperLogLogCommands.PfCountCommand given a key.MediaType object,
with this method name following the 'valueOf' naming convention
(as supported by ConversionService.MimeType object,
with this method name following the 'valueOf' naming convention
(as supported by ConversionService.List of values.ReactiveSetCommands.SAddCommand given a Collection of values.ReactiveSetCommands.SRemCommand given a Collection of values.ReactiveZSetCommands.ZRemCommand given a RedisZSetCommands.Tuple.key.key.ReactiveHyperLogLogCommands.PfCountCommand given a Collection of keys.ReactiveHyperLogLogCommands.PfMergeCommand given a Collection of sourceKeys.ReactiveZSetCommands.ZRangeCommand given a Range to obtain elements ordered from the lowest to the
highest score.ReactiveZSetCommands.ZRemRangeByRankCommand given a Range.PathContainer.PathSegment.valueToMatch() but as a char[].Vary header field name.MockRestServiceServer.expect(RequestMatcher) were indeed performed.Version.Version from the given integer values.MatcherVersion.VersionPathStrategy that adds a method
to determine the actual version of a Resource.Via header field name.ApplicationContext.View.void and String interpreting them
as view name reference.ViewResolver bean instance.ViewResolver that delegates to others.ViewResolver instances.ContentNegotiationManager and ApplicationContext.view-resolvers MVC namespace element and register
ViewResolver bean definitions.LongSupplier values with various spinning strategies.Warning header field name.ModelAndView.clear()
i.e. whether it does not hold any view and does not contain a model.NULL.keys for modifications during transaction started with RedisTxCommands.multi().key for modifications during transaction started with RedisOperations.multi().keys for modifications during transaction started with RedisOperations.multi().web.xml): "webAppRootKey".@WebAppConfiguration is a class-level annotation that is used to
declare that the ApplicationContext loaded for an integration test
should be a WebApplicationContext.MockMvcWebClientBuilder based on the supplied
WebApplicationContext.MockMvcWebClientBuilder based on the supplied
WebApplicationContext and MockMvcConfigurer.MockMvcHtmlUnitDriverBuilder based on the supplied
WebApplicationContext.MockMvcHtmlUnitDriverBuilder based on the supplied
WebApplicationContext and MockMvcConfigurer.MockMvc instance using the given, fully initialized
(i.e., refreshed) WebApplicationContext.ELResolver that exposes the Spring WebApplicationContext
instance under a variable named "webApplicationContext".WebApplicationContext for
a given ServletContext.ServletContext programmatically -- as opposed to (or possibly in conjunction
with) the traditional web.xml-based approach.WebApplicationContext.Callable, a timeout value, and a task executor.WebAsyncTask wrapping the given Callable.WebAsyncTask with a timeout value and a Callable.WebAsyncTask with a timeout value, an executor name, and a Callable.WebAsyncTask with a timeout value, an executor instance, and a Callable.WebDataBinder for performing
data binding in the context of a specific web request.WebConnectionHtmlUnitDriver enables configuration of the
WebConnection for an HtmlUnitDriver instance.AbstractController
and WebContentInterceptor.DataBinder for data binding from web request parameters
to JavaBean objects.WebDataBinder instance for a named target object.WebDelegatingSmartContextLoader is a concrete implementation of
AbstractDelegatingSmartContextLoader that delegates to a
GenericXmlWebContextLoader (or a GenericGroovyXmlWebContextLoader if
Groovy is present on the classpath) and an AnnotationConfigWebContextLoader.ServerWebInputException thrown when after data
binding and validation failure.DataBinder to perform data
binding from URL query params or form data in the request data to Java objects.WebFilter instances to add to the mock server.WebFilter to delegate to the next in the chain.WebHandler that decorates and delegates to another.ResourceResolver that delegates to the chain to locate a resource and then
attempts to find a matching versioned resource contained in a WebJar JAR file.WebJarsResourceResolver with a default WebJarAssetLocator instance.WebJarsResourceResolver with a custom WebJarAssetLocator instance,
e.g. with a custom index.JtaTransactionManager variant for BEA WebLogic (9.0 and higher).LoadTimeWeaver implementation for WebLogic's instrumentable
ClassLoader.WebLogicLoadTimeWeaver class using
the default class loader.WebLogicLoadTimeWeaver class using
the supplied ClassLoader.WebMergedContextConfiguration encapsulates the merged
context configuration declared on a test class and all of its superclasses
via @ContextConfiguration,
@WebAppConfiguration, and
@ActiveProfiles.WebMergedContextConfiguration instance by copying
all properties from the supplied MergedContextConfiguration.WebMergedContextConfiguration instance for the
supplied parameters.WebMergedContextConfiguration instance for the
supplied parameters.@EnableWebMvc.WebMvcConfigurer has default methods (made
possible by a Java 8 baseline) and can be implemented directly without the
need for this adapterDataBinder to perform data binding
from web request parameters to JavaBeans, including support for multipart files.WebRequest.WebSession for an HTTP request.WebSession persistence.DataSource implementation that delegates all calls to a WebSphere
target DataSource, typically obtained from JNDI, applying a current
isolation level and/or current user credentials to every Connection obtained
from it.LoadTimeWeaver implementation for WebSphere's instrumentable ClassLoader.WebSphereLoadTimeWeaver class using
the default class loader.WebSphereLoadTimeWeaver class using
the supplied ClassLoader.FactoryBean that obtains a WebSphere MBeanServer
reference through WebSphere's proprietary AdminServiceFactory API,
available on WebSphere 5.1 and higher.com.ibm.wsspi.uow.UOWManager instance, obtained from WebSphere's
JNDI environment.WebClient used to test with
internally delegating to a WebClient.Builder.WebFluxConfigurer.WebTestClient.WebTestClient.Builder and expose that
as a shortcut.TestContextBootstrapper SPI.Flux sequence into continuous, non-overlapping windows
where the window boundary is signalled by another Publisher

Flux sequence into potentially overlapping windows controlled by items of a
start Publisher and end Publisher derived from the start values.RequestPostProcessor.MockHttpServletRequest
in ways not built directly into the MockHttpServletRequestBuilder.Statement returned by the parent implementation with a
RunAfterTestClassCallbacks statement, thus preserving the default
JUnit functionality while adding support for the Spring TestContext Framework.Statement returned by the parent implementation with a
RunAfterTestMethodCallbacks statement, thus preserving the
default functionality while adding support for the Spring TestContext
Framework.Statement with a RunAfterTestExecutionCallbacks
statement, thus preserving the default functionality while adding support for the
Spring TestContext Framework.RedisGeoCommands.GeoRadiusCommandArgs.RedisGeoCommands.GeoRadiusCommandArgs.RepositoryComposition retaining current configuration and set argumentConverter.ResponseCreator for a 400 response (BAD_REQUEST).Statement returned by the parent implementation with a
RunBeforeTestClassCallbacks statement, thus preserving the
default JUnit functionality while adding support for the Spring TestContext
Framework.Statement returned by the parent implementation with a
RunBeforeTestMethodCallbacks statement, thus preserving the
default functionality while adding support for the Spring TestContext
Framework.Statement with a RunBeforeTestExecutionCallbacks
statement, thus preserving the default functionality while adding support for the
Spring TestContext Framework.Pair if both Optional instances have values or Optional.empty() if one or both
are missing.ComparisonControllers.Default with your own ComparisonController.MvcUriComponentsBuilder.fromController(Class) for use with an instance
of this class created via a call to MvcUriComponentsBuilder.relativeTo(org.springframework.web.util.UriComponentsBuilder).ConversionService.ResponseCreator for a 201 response (CREATED) with a 'Location' header.DifferenceEvaluator implementation.ComparisonResult.EQUAL.ResultProcessor with a new projection type obtained from the given ParameterAccessor.flags.flags.RepositoryFragment given its implementation object.ReactiveGeoCommands.GeoRadiusByMemberCommand given a Distance.ReactiveGeoCommands.GeoRadiusCommand given a Distance.ReactiveGeoCommands.GeoRadiusCommand given a Circle.Range.Range.ReactiveGeoCommands.GeoRadiusByMemberCommand given a distance in RedisGeoCommands.DistanceUnit.FEET.ReactiveGeoCommands.GeoRadiusCommand given a distance in RedisGeoCommands.DistanceUnit.FEET.ReactiveGeoCommands.GeoRadiusCommand given a distance in RedisGeoCommands.DistanceUnit.KILOMETERS.ReactiveGeoCommands.GeoRadiusByMemberCommand given a distance in RedisGeoCommands.DistanceUnit.KILOMETERS.ReactiveGeoCommands.GeoRadiusByMemberCommand given a distance in RedisGeoCommands.DistanceUnit.METERS.ReactiveGeoCommands.GeoRadiusCommand given a distance in RedisGeoCommands.DistanceUnit.METERS.ReactiveGeoCommands.GeoRadiusByMemberCommand given a distance in RedisGeoCommands.DistanceUnit.MILES.ReactiveGeoCommands.GeoRadiusCommand given a distance in RedisGeoCommands.DistanceUnit.MILES.DataBindingMethodResolver for instance method invocation purposes
(i.e. not supporting static methods) in addition to the specified property accessors,
typically in combination with a DataBindingPropertyAccessor.Flux and another
Publisher through a BiFunction and emits the result.MvcUriComponentsBuilder.fromMappingName(String) for use with an instance
of this class created via MvcUriComponentsBuilder.relativeTo(org.springframework.web.util.UriComponentsBuilder).Marshaller to use when creating the Source.MvcUriComponentsBuilder.fromMethod(Class, Method, Object...)MvcUriComponentsBuilder.fromMethodCall(Object) for use with an instance
of this class created via MvcUriComponentsBuilder.relativeTo(org.springframework.web.util.UriComponentsBuilder).RepositoryComposition retaining current configuration and set methodLookup.MvcUriComponentsBuilder.fromMethodName(Class, String, Object...)} for
use with an instance of this class created via MvcUriComponentsBuilder.relativeTo(org.springframework.web.util.UriComponentsBuilder).MethodResolver delegates for
a combination of property access and method resolution.Comparison.Detail#getXPath.ResponseCreator for a 204 response (NO_CONTENT).Statement with a SpringRepeat statement.BlockJUnit4ClassRunner.withPotentialTimeout(FrameworkMethod, Object, Statement)
but with additional support for Spring's @Timed annotation.MockEnvironment.setProperty(java.lang.String, java.lang.String) that returns the current instance.MockPropertySource.setProperty(java.lang.String, java.lang.Object) that returns the current instance.ResponseCreator for a 500 response (SERVER_ERROR).RedisStringCommands.SetOption.ResponseCreator with a specific HTTP status.ResponseCreator for a 200 response (OK).ResponseCreator for a 200 response (OK) with String body.ResponseCreator for a 200 response (OK) with byte[] body.ResponseCreator for a 200 response (OK) content with Resource-based body.Input.from(Object).TypeConverter.ResponseCreator for a 401 response (UNAUTHORIZED).TaskExecutor implementation
that delegates to a JCA 1.7 WorkManager, implementing the
javax.resource.spi.work.WorkManager interface.commonj.work.WorkManager interface,
which either needs to be specified as reference or through the JNDI name.WorkQueueProcessor builder that can be used to create new
processors.Exception
(typically PropertyAccessException)
or a Bean Validation ConstraintViolation.element to its ByteBuffer representation.element to its ByteBuffer representation.HttpMessageWriter.write(Publisher, ResolvableType, MediaType, ReactiveHttpOutputMessage, Map)
with additional context available.AbstractHttpMessageConverter.addDefaultHeaders(org.springframework.http.HttpHeaders, T, org.springframework.http.MediaType),
and then calls AbstractGenericHttpMessageConverter.writeInternal(T, org.springframework.http.HttpOutputMessage).AbstractHttpMessageConverter.addDefaultHeaders(org.springframework.http.HttpHeaders, T, org.springframework.http.MediaType),
and then calls AbstractHttpMessageConverter.writeInternal(T, org.springframework.http.HttpOutputMessage).Publisher of Publishers to write the body
of the HttpOutputMessage to the underlying HTTP layer, flushing after
each Publisher<DataBuffer>.ServerHttpResponseDecorator.setComplete() without writing.Publisher<DataBuffer>.TagWriter.TagWriter.Writer.TagWriter.TagWriter.null
or zero length.HttpMessageWriter.HttpMessageWriter.input' element to the supplied
TagWriter,
marking it as 'checked' if appropriate.input type="radio"' element with the configured
AbstractMultiCheckedElementTag.setItems(Object) values.input(radio)' element with the configured
value.form' tag and exposes
the form object name in the javax.servlet.jsp.PageContext.input' tag to the supplied TagWriter including the
databound value.input' tag to the supplied TagWriter.label' tag and forces a block tag so
that body content is written correctly.select' tag to the supplied
TagWriter.OutputStream.AbstractXmlHttpMessageConverter.writeInternal(Object, HttpOutputMessage).value' attribute to the supplied TagWriter.value' attribute to the supplied TagWriter.Publisher to write the body of the message to the
underlying HTTP layer.reduce on the body, count
the number of bytes produced, release data buffers without writing, and
set the Content-Length header.File to write the body of the message to the underlying
HTTP layer.WWW-Authenticate header field name.Jackson2ObjectMapperBuilder instance in order to
build an XmlMapper instance.HttpMessageConverter to create XMLBeam-based projection instances for interfaces.XmlBeamHttpMessageConverter.XmlBeamHttpMessageConverter using the given XBProjector.OutputStream
data for XML input.Writer
data for XML input.DataBuffer stream into a stream of XMLEvents.XmlMappingException with the specified detail message.XmlMappingException with the specified detail message
and nested exception.RepositoryConfigurationSource.Result
data for XML input.ViewResolver implementation that uses
bean definitions in a dedicated XML file for view definitions, specified by
resource location.WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader.XPathContext.NodeInfo.XPathContext.RequestMatcher's using an XPath
expression.ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet.Marshaller interface for XStream.RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.ReactiveZSetCommands.ZAddCommand.getTuples() to a sorted set at ReactiveRedisConnection.KeyCommand.getKey(), or update its score
if it already exists.value to a sorted set at key, or update its score if it already exists.tuples to a sorted set at key, or update its score if it already exists.value to a sorted set at key, or update its score if it already exists.tuples to a sorted set at key, or update its score if it already exists.RedisConnection.zSetCommands()}.ReactiveRedisConnection.KeyCommand.getKey().key.key.key.RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.Range.Range.min and max.Range#min and Range#max.min and max.ReactiveOutputMessage that has support for "zero-copy"
file transfers.RedisConnection.zSetCommands()}.ReactiveZSetCommands.ZIncrByCommand.getValue() in sorted set by
ReactiveZSetCommands.ZIncrByCommand.getIncrement().value in sorted set by increment.value in sorted set by increment.RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.sets and store result in destination key.sets and store result in destination key.sets and store result in destination key.sets and store result in destination key.Tuple2.Tuple3.Tuple4.Tuple5.Tuple6.Tuple2.Tuple3.Tuple4.Tuple5.Tuple6.Tuple2 and delaying errors.Tuple3 and delaying errors.Tuple4 and delaying errors.Tuple5 and delaying errors.Tuple6 and delaying errors.rightGenerator function and combine both results into a Tuple2.rightGenerator function and combine both results into an arbitrary
O object, as defined by the provided combinator function.Flux with another Publisher source, that is to say wait
for both to emit one element and combine these elements using a combinator
BiFunction
The operator will continue doing so until any of the sources completes.Flux with another Publisher source, that is to say wait
for both to emit one element and combine these elements using a combinator
BiFunction
The operator will continue doing so until any of the sources completes.Tuple2.O object,
as defined by the provided combinator function.Flux with the content of an Iterable, that is
to say combine one element from each, pairwise, using the given zipper BiFunction.RedisConnection.zSetCommands()}.RedisZSetCommands.Tuples in range from sorted set.start and end from sorted set.start and end from sorted set.RedisConnection.zSetCommands()}.Range from the sorted set at key in lexicographical ordering.Range from the sorted set at key in lexicographical ordering.Range from the sorted set at key in lexicographical ordering.RedisZSetCommands.Range from the sorted set at key in lexicographical ordering.RedisZSetCommands.Range from the sorted set at key in lexicographical ordering.Range from the sorted set at key in lexicographical ordering.Range from the sorted set at key in lexicographical ordering.RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.RedisZSetCommands.Tuples in range from sorted set.min and max from sorted set.start to end where score is between min and max from
sorted set.min and max from sorted set.Range#min and Range#max from sorted set.start to end where score is between min and max from
sorted set.Limit#count to Limit#offset where score is between Range#min and
Range#max from sorted set.min and max from sorted set.start to end where score is between min and max from
sorted set.min and max from sorted set.start to end where score is between min and max from
sorted set.RedisConnection.zSetCommands()}.RedisZSetCommands.Tuples in range from sorted set.RedisZSetCommands.Tuples in range from sorted set.RedisZSetCommands.Tuples in range from start to end where score is between min and
max from sorted set.RedisZSetCommands.Tuples in range from Limit#offset to Limit#offset + Limit#count where score is
between Range#min and Range#max from sorted set.Tuples where score is between min and max from sorted set.Tuples in range from start to end where score is between min and
max from sorted set.RedisConnection.zSetCommands()}.RedisZSetCommands.Tuples in range from sorted set.Tuples between start and end from sorted set.RedisConnection.zSetCommands()}.ReactiveZSetCommands.ZRankCommand.getDirection().value in a sorted set.value in a sorted set.RedisConnection.zSetCommands()}.ReactiveZSetCommands.ZRemCommand.getValues() from sorted set.values from sorted set.values from sorted set.RedisConnection.zSetCommands()}.start and end from sorted set with key.start and end from sorted set with key.Range from sorted set with key.Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.Range from sorted set with key.Range from sorted set with ReactiveRedisConnection.KeyCommand.getKey().min and max from sorted set with key.Range#min and Range#max from sorted set with key.min and max from sorted set with key.RedisConnection.zSetCommands()}.start to end from sorted set ordered from high to low.start to end from sorted set ordered from high to low.Range from the sorted set at key in lexicographical ordering.Range from the sorted set at key in lexicographical ordering.RedisConnection.zSetCommands()}.min and max from sorted set ordered from high to low.Range#min and Range#max from sorted set ordered from high to
low.start to end where score is between min and max from
sorted set ordered high -> low.Limit#offset to Limit#offset + Limit#count where score is between
Range#min and Range#max from sorted set ordered high -> low.min and max from sorted set ordered from high to low.start to end where score is between min and max from
sorted set ordered high -> low.RedisConnection.zSetCommands()}.RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to
low.RedisZSetCommands.Tuple in range from start to end where score is between min and
max from sorted set ordered high -> low.RedisZSetCommands.Tuple where score is between Range#min and Range#max from sorted set ordered
from high to low.RedisZSetCommands.Tuple in range from Limit#offset to Limit#count where score is between
Range#min and Range#max from sorted set ordered high -> low.Tuple where score is between min and max from sorted set ordered from high to
low.Tuple in range from start to end where score is between min and
max from sorted set ordered high -> low.RedisConnection.zSetCommands()}.RedisZSetCommands.Tuples in range from sorted set in reverse score ordering.RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.Tuples in range from start to end from sorted set ordered from high to low.RedisConnection.zSetCommands()}.value in a sorted set when scored high to low.value in a sorted set when scored high to low.RedisConnection.zSetCommands()}.Cursor to iterate over elements in sorted set at key.Cursor to iterate over elements in sorted set at key.RedisConnection.zSetCommands()}.ReactiveZSetCommands.ZScoreCommand.getValue() from sorted set with key
ReactiveRedisConnection.KeyCommand.getKey()value from sorted set with key key.value from sorted set with key key.ReactiveZSetCommands.RedisZSetCommands.RedisConnection.zSetCommands()}.RedisConnection.zSetCommands()}.sets and store result in destination key.sets and store result in destination key.sets and store result in destination key.sets and store result in destination key.